Import LLVM 10.0.0 release including clang, lld and lldb.

ok hackroom
tested by plenty

1 files changed, 218 insertions, 0 deletions

diff --git a/gnu/llvm/lldb/source/Host/posix/ProcessLauncherPosixFork.cpp b/gnu/llvm/lldb/source/Host/posix/ProcessLauncherPosixFork.cpp
new file mode 100644
index 00000000000..185c7f0fe24
--- /dev/null
+++ b/gnu/llvm/lldb/source/Host/posix/ProcessLauncherPosixFork.cpp
@@ -0,0 +1,218 @@
+//===-- ProcessLauncherPosixFork.cpp ----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/posix/ProcessLauncherPosixFork.h"
+#include "lldb/Host/Host.h"
+#include "lldb/Host/HostProcess.h"
+#include "lldb/Host/Pipe.h"
+#include "lldb/Host/ProcessLaunchInfo.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Log.h"
+#include "llvm/Support/Errno.h"
+
+#include <limits.h>
+#include <sys/ptrace.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <sstream>
+#include <csignal>
+
+#ifdef __ANDROID__
+#include <android/api-level.h>
+#define PT_TRACE_ME PTRACE_TRACEME
+#endif
+
+#if defined(__ANDROID_API__) && __ANDROID_API__ < 15
+#include <linux/personality.h>
+#elif defined(__linux__)
+#include <sys/personality.h>
+#endif
+
+using namespace lldb;
+using namespace lldb_private;
+
+static void FixupEnvironment(Environment &env) {
+#ifdef __ANDROID__
+  // If there is no PATH variable specified inside the environment then set the
+  // path to /system/bin. It is required because the default path used by
+  // execve() is wrong on android.
+  env.try_emplace("PATH", "/system/bin");
+#endif
+}
+
+static void LLVM_ATTRIBUTE_NORETURN ExitWithError(int error_fd,
+                                                  const char *operation) {
+  int err = errno;
+  llvm::raw_fd_ostream os(error_fd, true);
+  os << operation << " failed: " << llvm::sys::StrError(err);
+  os.flush();
+  _exit(1);
+}
+
+static void DisableASLRIfRequested(int error_fd, const ProcessLaunchInfo &info) {
+#if defined(__linux__)
+  if (info.GetFlags().Test(lldb::eLaunchFlagDisableASLR)) {
+    const unsigned long personality_get_current = 0xffffffff;
+    int value = personality(personality_get_current);
+    if (value == -1)
+      ExitWithError(error_fd, "personality get");
+
+    value = personality(ADDR_NO_RANDOMIZE | value);
+    if (value == -1)
+      ExitWithError(error_fd, "personality set");
+  }
+#endif
+}
+
+static void DupDescriptor(int error_fd, const FileSpec &file_spec, int fd,
+                          int flags) {
+  int target_fd = llvm::sys::RetryAfterSignal(-1, ::open,
+      file_spec.GetCString(), flags, 0666);
+
+  if (target_fd == -1)
+    ExitWithError(error_fd, "DupDescriptor-open");
+
+  if (target_fd == fd)
+    return;
+
+  if (::dup2(target_fd, fd) == -1)
+    ExitWithError(error_fd, "DupDescriptor-dup2");
+
+  ::close(target_fd);
+  return;
+}
+
+static void LLVM_ATTRIBUTE_NORETURN ChildFunc(int error_fd,
+                                              const ProcessLaunchInfo &info) {
+  if (info.GetFlags().Test(eLaunchFlagLaunchInSeparateProcessGroup)) {
+    if (setpgid(0, 0) != 0)
+      ExitWithError(error_fd, "setpgid");
+  }
+
+  for (size_t i = 0; i < info.GetNumFileActions(); ++i) {
+    const FileAction &action = *info.GetFileActionAtIndex(i);
+    switch (action.GetAction()) {
+    case FileAction::eFileActionClose:
+      if (close(action.GetFD()) != 0)
+        ExitWithError(error_fd, "close");
+      break;
+    case FileAction::eFileActionDuplicate:
+      if (dup2(action.GetFD(), action.GetActionArgument()) == -1)
+        ExitWithError(error_fd, "dup2");
+      break;
+    case FileAction::eFileActionOpen:
+      DupDescriptor(error_fd, action.GetFileSpec(), action.GetFD(),
+                    action.GetActionArgument());
+      break;
+    case FileAction::eFileActionNone:
+      break;
+    }
+  }
+
+  const char **argv = info.GetArguments().GetConstArgumentVector();
+
+  // Change working directory
+  if (info.GetWorkingDirectory() &&
+      0 != ::chdir(info.GetWorkingDirectory().GetCString()))
+    ExitWithError(error_fd, "chdir");
+
+  DisableASLRIfRequested(error_fd, info);
+  Environment env = info.GetEnvironment();
+  FixupEnvironment(env);
+  Environment::Envp envp = env.getEnvp();
+
+  // Clear the signal mask to prevent the child from being affected by any
+  // masking done by the parent.
+  sigset_t set;
+  if (sigemptyset(&set) != 0 ||
+      pthread_sigmask(SIG_SETMASK, &set, nullptr) != 0)
+    ExitWithError(error_fd, "pthread_sigmask");
+
+  if (info.GetFlags().Test(eLaunchFlagDebug)) {
+    // Do not inherit setgid powers.
+    if (setgid(getgid()) != 0)
+      ExitWithError(error_fd, "setgid");
+
+    // HACK:
+    // Close everything besides stdin, stdout, and stderr that has no file
+    // action to avoid leaking. Only do this when debugging, as elsewhere we
+    // actually rely on passing open descriptors to child processes.
+    for (int fd = 3; fd < sysconf(_SC_OPEN_MAX); ++fd)
+      if (!info.GetFileActionForFD(fd) && fd != error_fd)
+        close(fd);
+
+    // Start tracing this child that is about to exec.
+    if (ptrace(PT_TRACE_ME, 0, nullptr, 0) == -1)
+      ExitWithError(error_fd, "ptrace");
+  }
+
+  // Execute.  We should never return...
+  execve(argv[0], const_cast<char *const *>(argv), envp);
+
+#if defined(__linux__)
+  if (errno == ETXTBSY) {
+    // On android M and earlier we can get this error because the adb daemon
+    // can hold a write handle on the executable even after it has finished
+    // uploading it. This state lasts only a short time and happens only when
+    // there are many concurrent adb commands being issued, such as when
+    // running the test suite. (The file remains open when someone does an "adb
+    // shell" command in the fork() child before it has had a chance to exec.)
+    // Since this state should clear up quickly, wait a while and then give it
+    // one more go.
+    usleep(50000);
+    execve(argv[0], const_cast<char *const *>(argv), envp);
+  }
+#endif
+
+  // ...unless exec fails.  In which case we definitely need to end the child
+  // here.
+  ExitWithError(error_fd, "execve");
+}
+
+HostProcess
+ProcessLauncherPosixFork::LaunchProcess(const ProcessLaunchInfo &launch_info,
+                                        Status &error) {
+  char exe_path[PATH_MAX];
+  launch_info.GetExecutableFile().GetPath(exe_path, sizeof(exe_path));
+
+  // A pipe used by the child process to report errors.
+  PipePosix pipe;
+  const bool child_processes_inherit = false;
+  error = pipe.CreateNew(child_processes_inherit);
+  if (error.Fail())
+    return HostProcess();
+
+  ::pid_t pid = ::fork();
+  if (pid == -1) {
+    // Fork failed
+    error.SetErrorStringWithFormatv("Fork failed with error message: {0}",
+                                    llvm::sys::StrError());
+    return HostProcess(LLDB_INVALID_PROCESS_ID);
+  }
+  if (pid == 0) {
+    // child process
+    pipe.CloseReadFileDescriptor();
+    ChildFunc(pipe.ReleaseWriteFileDescriptor(), launch_info);
+  }
+
+  // parent process
+
+  pipe.CloseWriteFileDescriptor();
+  char buf[1000];
+  int r = read(pipe.GetReadFileDescriptor(), buf, sizeof buf);
+
+  if (r == 0)
+    return HostProcess(pid); // No error. We're done.
+
+  error.SetErrorString(buf);
+
+  llvm::sys::RetryAfterSignal(-1, waitpid, pid, nullptr, 0);
+
+  return HostProcess();
+}