third_party/llvm-project/lldb/tools/darwin-debug/darwin-debug.cpp - cobalt - Git at Google

 //===-- 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__)
	//===-- 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__)