vendor/lldb/lldb-trunk-r256945

1 files changed, 354 insertions, 0 deletions

diff --git a/tools/darwin-debug/darwin-debug.cpp b/tools/darwin-debug/darwin-debug.cpp
new file mode 100644
index 000000000000..ca0a8d48328b
--- /dev/null
+++ b/tools/darwin-debug/darwin-debug.cpp
@@ -0,0 +1,354 @@
+//===-- Launcher.cpp --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+//----------------------------------------------------------------------
+// Darwin launch helper
+//
+// This program was written to allow programs to be launched in a new
+// Terminal.app window and have the application be stopped for debugging
+// at the program entry point.
+//
+// Although it uses posix_spawn(), it uses Darwin specific posix spawn
+// attribute flags to accomplish its task. It uses an "exec only" flag
+// which avoids forking this process, and it uses a "stop at entry"
+// flag to stop the program at the entry point.
+// 
+// Since it uses darwin specific flags this code should not be compiled
+// on other systems.
+//----------------------------------------------------------------------
+#if defined (__APPLE__)
+
+#include <crt_externs.h> // for _NSGetEnviron()
+#include <getopt.h>
+#include <limits.h>
+#include <mach/machine.h>
+#include <signal.h>
+#include <spawn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/un.h>
+
+#include <string>
+
+#ifndef _POSIX_SPAWN_DISABLE_ASLR
+#define _POSIX_SPAWN_DISABLE_ASLR       0x0100
+#endif
+
+#define streq(a,b) strcmp(a,b) == 0
+
+static struct option g_long_options[] = 
+{
+	{ "arch",			required_argument,	NULL,           'a'		},
+	{ "disable-aslr",   no_argument,		NULL,           'd'		},
+	{ "no-env",         no_argument,		NULL,           'e'		},
+	{ "help",           no_argument,		NULL,           'h'		},
+	{ "setsid",         no_argument,		NULL,           's'		},
+	{ "unix-socket",    required_argument,  NULL,           'u'		},
+    { "working-dir",    required_argument,  NULL,           'w'     },
+    { "env",            required_argument,  NULL,           'E'     },
+	{ NULL,				0,					NULL,            0		}
+};
+
+static void
+usage()
+{
+    puts (
+"NAME\n"
+"    darwin-debug -- posix spawn a process that is stopped at the entry point\n"
+"                    for debugging.\n"
+"\n"
+"SYNOPSIS\n"
+"    darwin-debug --unix-socket=<SOCKET> [--arch=<ARCH>] [--working-dir=<PATH>] [--disable-aslr] [--no-env] [--setsid] [--help] -- <PROGRAM> [<PROGRAM-ARG> <PROGRAM-ARG> ....]\n"
+"\n"
+"DESCRIPTION\n"
+"    darwin-debug will exec itself into a child process <PROGRAM> that is\n"
+"    halted for debugging. It does this by using posix_spawn() along with\n"
+"    darwin specific posix_spawn flags that allows exec only (no fork), and\n"
+"    stop at the program entry point. Any program arguments <PROGRAM-ARG> are\n"
+"    passed on to the exec as the arguments for the new process. The current\n"
+"    environment will be passed to the new process unless the \"--no-env\"\n"
+"    option is used. A unix socket must be supplied using the\n"
+"    --unix-socket=<SOCKET> option so the calling program can handshake with\n"
+"    this process and get its process id.\n"
+"\n"
+"EXAMPLE\n"
+"   darwin-debug --arch=i386 -- /bin/ls -al /tmp\n"
+);
+    exit (1);
+}
+
+static void
+exit_with_errno (int err, const char *prefix)
+{
+    if (err)
+    {
+        fprintf (stderr, 
+                 "%s%s", 
+                 prefix ? prefix : "", 
+                 strerror(err));
+        exit (err);
+    }
+}
+
+pid_t
+posix_spawn_for_debug 
+(
+    char *const *argv, 
+    char *const *envp, 
+    const char *working_dir,
+    cpu_type_t cpu_type, 
+    int disable_aslr)
+{
+    pid_t pid = 0;
+
+    const char *path = argv[0];
+
+    posix_spawnattr_t attr;
+
+    exit_with_errno (::posix_spawnattr_init (&attr), "::posix_spawnattr_init (&attr) error: ");
+
+    // Here we are using a darwin specific feature that allows us to exec only
+    // since we want this program to turn into the program we want to debug, 
+    // and also have the new program start suspended (right at __dyld_start)
+    // so we can debug it
+    short flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETEXEC | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK;
+
+    // Disable ASLR if we were asked to
+    if (disable_aslr)
+        flags |= _POSIX_SPAWN_DISABLE_ASLR;
+    
+    sigset_t no_signals;
+    sigset_t all_signals;
+    sigemptyset (&no_signals);
+    sigfillset (&all_signals);
+    ::posix_spawnattr_setsigmask(&attr, &no_signals);
+    ::posix_spawnattr_setsigdefault(&attr, &all_signals);
+    
+    // Set the flags we just made into our posix spawn attributes
+    exit_with_errno (::posix_spawnattr_setflags (&attr, flags), "::posix_spawnattr_setflags (&attr, flags) error: ");
+    
+    
+    // Another darwin specific thing here where we can select the architecture
+    // of the binary we want to re-exec as.
+    if (cpu_type != 0)
+    {
+        size_t ocount = 0;
+        exit_with_errno (::posix_spawnattr_setbinpref_np (&attr, 1, &cpu_type, &ocount), "posix_spawnattr_setbinpref_np () error: ");
+    }
+    
+    // I wish there was a posix_spawn flag to change the working directory of
+    // the inferior process we will spawn, but there currently isn't. If there
+    // ever is a better way to do this, we should use it. I would rather not
+    // manually fork, chdir in the child process, and then posix_spawn with exec
+    // as the whole reason for doing posix_spawn is to not hose anything up
+    // after the fork and prior to the exec...
+    if (working_dir)
+        ::chdir (working_dir);
+
+    exit_with_errno (::posix_spawnp (&pid, path, NULL, &attr, (char * const*)argv, (char * const*)envp), "posix_spawn() error: ");
+    
+    // This code will only be reached if the posix_spawn exec failed...
+    ::posix_spawnattr_destroy (&attr);
+
+    return pid;
+}
+
+
+int main (int argc, char *const *argv, char *const *envp, const char **apple)
+{
+#if defined (DEBUG_LLDB_LAUNCHER)
+    const char *program_name = strrchr(apple[0], '/');
+    
+    if (program_name)
+        program_name++; // Skip the last slash..
+    else
+        program_name = apple[0];
+    
+    printf("%s called with:\n", program_name);
+    for (int i=0; i<argc; ++i)
+        printf("argv[%u] = '%s'\n", i, argv[i]);
+#endif
+
+    cpu_type_t cpu_type = 0;
+    bool show_usage = false;
+    int ch;
+    int disable_aslr = 0; // By default we disable ASLR
+    bool pass_env = true;
+    std::string unix_socket_name;
+    std::string working_dir;
+    
+#if __GLIBC__
+    optind = 0;
+#else
+    optreset = 1;
+    optind = 1;
+#endif
+
+	while ((ch = getopt_long_only(argc, argv, "a:deE:hsu:?", g_long_options, NULL)) != -1)
+	{
+		switch (ch) 
+		{
+        case 0:
+            break;
+
+		case 'a':	// "-a i386" or "--arch=i386"
+			if (optarg)
+			{
+				if (streq (optarg, "i386"))
+                    cpu_type = CPU_TYPE_I386;
+				else if (streq (optarg, "x86_64"))
+                    cpu_type = CPU_TYPE_X86_64;
+                else if (streq (optarg, "x86_64h"))
+                    cpu_type = 0; // Don't set CPU type when we have x86_64h
+                else if (strstr (optarg, "arm") == optarg)
+                    cpu_type = CPU_TYPE_ARM;
+                else
+                {
+                    ::fprintf (stderr, "error: unsupported cpu type '%s'\n", optarg);
+                    ::exit (1);
+                }
+			} 
+			break;
+
+        case 'd':
+            disable_aslr = 1;
+            break;            
+
+        case 'e':
+            pass_env = false;
+            break;
+            
+        case 'E':
+            {
+                // Since we will exec this program into our new program, we can just set environment
+                // variables in this process and they will make it into the child process.
+                std::string name;
+                std::string value;
+                const char *equal_pos = strchr (optarg, '=');
+                if (equal_pos)
+                {
+                    name.assign (optarg, equal_pos - optarg);
+                    value.assign (equal_pos + 1);
+                }
+                else
+                {
+                    name = optarg;
+                }
+                ::setenv (name.c_str(), value.c_str(), 1);
+            }
+            break;
+            
+        case 's':
+            // Create a new session to avoid having control-C presses kill our current
+            // terminal session when this program is launched from a .command file
+            ::setsid();
+            break;
+
+        case 'u':
+            unix_socket_name.assign (optarg);
+            break;
+
+        case 'w':
+            {
+                struct stat working_dir_stat;
+                if (stat (optarg, &working_dir_stat) == 0)
+                    working_dir.assign (optarg);
+                else
+                    ::fprintf(stderr, "warning: working directory doesn't exist: '%s'\n", optarg);
+            }
+            break;
+
+		case 'h':
+		case '?':
+		default:
+			show_usage = true;
+			break;
+		}
+	}
+	argc -= optind;
+	argv += optind;
+
+    if (show_usage || argc <= 0 || unix_socket_name.empty())
+        usage();
+
+#if defined (DEBUG_LLDB_LAUNCHER)
+    printf ("\n%s post options:\n", program_name);
+    for (int i=0; i<argc; ++i)
+        printf ("argv[%u] = '%s'\n", i, argv[i]);
+#endif
+
+    // Open the socket that was passed in as an option
+    struct sockaddr_un saddr_un;
+    int s = ::socket (AF_UNIX, SOCK_STREAM, 0);
+    if (s < 0)
+    {
+        perror("error: socket (AF_UNIX, SOCK_STREAM, 0)");
+        exit(1);
+    }
+
+    saddr_un.sun_family = AF_UNIX;
+    ::strncpy(saddr_un.sun_path, unix_socket_name.c_str(), sizeof(saddr_un.sun_path) - 1);
+    saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
+    saddr_un.sun_len = SUN_LEN (&saddr_un);
+
+    if (::connect (s, (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) < 0) 
+    {
+        perror("error: connect (socket, &saddr_un, saddr_un_len)");
+        exit(1);
+    }
+    
+    // We were able to connect to the socket, now write our PID so whomever
+    // launched us will know this process's ID
+    char pid_str[64];
+    const int pid_str_len = ::snprintf (pid_str, sizeof(pid_str), "%i", ::getpid());
+    const int bytes_sent = ::send (s, pid_str, pid_str_len, 0);
+    
+    if (pid_str_len != bytes_sent)
+    {
+        perror("error: send (s, pid_str, pid_str_len, 0)");
+        exit (1);
+    }
+
+    // We are done with the socket
+    close (s);
+
+    system("clear");
+    printf ("Launching: '%s'\n", argv[0]);
+    if (working_dir.empty())
+    {
+        char cwd[PATH_MAX];
+        const char *cwd_ptr = getcwd(cwd, sizeof(cwd));
+        printf ("Working directory: '%s'\n", cwd_ptr);
+    }
+    else
+    {
+        printf ("Working directory: '%s'\n", working_dir.c_str());
+    }
+    printf ("%i arguments:\n", argc);
+
+    for (int i=0; i<argc; ++i)
+        printf ("argv[%u] = '%s'\n", i, argv[i]);
+
+    // Now we posix spawn to exec this process into the inferior that we want
+    // to debug.
+    posix_spawn_for_debug (argv,
+                           pass_env ? *_NSGetEnviron() : NULL, // Pass current environment as we may have modified it if "--env" options was used, do NOT pass "envp" here
+                           working_dir.empty() ? NULL : working_dir.c_str(),
+                           cpu_type, 
+                           disable_aslr);
+    
+	return 0;
+}
+
+#endif // #if defined (__APPLE__)
+