Vendor import of lldb trunk r256945:

https://llvm.org/svn/llvm-project/lldb/trunk@256945

1 files changed, 404 insertions, 0 deletions

diff --git a/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp b/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp
new file mode 100644
index 0000000..c65b225
--- /dev/null
+++ b/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp
@@ -0,0 +1,404 @@
+#include <cstdlib>
+#include <cstring>
+#include <errno.h>
+#include <inttypes.h>
+#include <memory>
+#include <pthread.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <vector>
+
+#if defined(__APPLE__)
+__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2)
+int pthread_threadid_np(pthread_t,__uint64_t*);
+#elif defined(__linux__)
+#include <sys/syscall.h>
+#endif
+
+#if defined(__linux__)
+#include <sys/prctl.h>
+#endif
+
+static const char *const RETVAL_PREFIX               = "retval:";
+static const char *const SLEEP_PREFIX                = "sleep:";
+static const char *const STDERR_PREFIX               = "stderr:";
+static const char *const SET_MESSAGE_PREFIX          = "set-message:";
+static const char *const PRINT_MESSAGE_COMMAND       = "print-message:";
+static const char *const GET_DATA_ADDRESS_PREFIX     = "get-data-address-hex:";
+static const char *const GET_STACK_ADDRESS_COMMAND   = "get-stack-address-hex:";
+static const char *const GET_HEAP_ADDRESS_COMMAND    = "get-heap-address-hex:";
+
+static const char *const GET_CODE_ADDRESS_PREFIX     = "get-code-address-hex:";
+static const char *const CALL_FUNCTION_PREFIX        = "call-function:";
+
+static const char *const THREAD_PREFIX = "thread:";
+static const char *const THREAD_COMMAND_NEW = "new";
+static const char *const THREAD_COMMAND_PRINT_IDS = "print-ids";
+static const char *const THREAD_COMMAND_SEGFAULT = "segfault";
+
+static bool g_print_thread_ids = false;
+static pthread_mutex_t g_print_mutex = PTHREAD_MUTEX_INITIALIZER;
+static bool g_threads_do_segfault = false;
+
+static pthread_mutex_t g_jump_buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
+static jmp_buf g_jump_buffer;
+static bool g_is_segfaulting = false;
+
+static char g_message[256];
+
+static volatile char g_c1 = '0';
+static volatile char g_c2 = '1';
+
+static void
+print_thread_id ()
+{
+	// Put in the right magic here for your platform to spit out the thread id (tid) that debugserver/lldb-gdbserver would see as a TID.
+	// Otherwise, let the else clause print out the unsupported text so that the unit test knows to skip verifying thread ids.
+#if defined(__APPLE__)
+	__uint64_t tid = 0;
+	pthread_threadid_np(pthread_self(), &tid);
+	printf ("%" PRIx64, tid);
+#elif defined (__linux__)
+	// This is a call to gettid() via syscall.
+	printf ("%" PRIx64, static_cast<uint64_t> (syscall (__NR_gettid)));
+#else
+	printf("{no-tid-support}");
+#endif
+}
+
+static void
+signal_handler (int signo)
+{
+	const char *signal_name = nullptr;
+	switch (signo)
+	{
+		case SIGUSR1: signal_name = "SIGUSR1"; break;
+		case SIGSEGV: signal_name = "SIGSEGV"; break;
+		default:      signal_name = nullptr;
+	}
+
+	// Print notice that we received the signal on a given thread.
+	pthread_mutex_lock (&g_print_mutex);
+	if (signal_name)
+		printf ("received %s on thread id: ", signal_name);
+	else
+		printf ("received signo %d (%s) on thread id: ", signo, strsignal (signo));
+	print_thread_id ();
+	printf ("\n");
+	pthread_mutex_unlock (&g_print_mutex);
+
+	// Reset the signal handler if we're one of the expected signal handlers.
+	switch (signo)
+	{
+        case SIGSEGV:
+	        if (g_is_segfaulting)
+	        {
+	            // Fix up the pointer we're writing to.  This needs to happen if nothing intercepts the SIGSEGV
+	            // (i.e. if somebody runs this from the command line).
+	            longjmp(g_jump_buffer, 1);
+			}
+            break;
+        case SIGUSR1:
+            if (g_is_segfaulting)
+            {
+                // Fix up the pointer we're writing to.  This is used to test gdb remote signal delivery.
+                // A SIGSEGV will be raised when the thread is created, switched out for a SIGUSR1, and
+                // then this code still needs to fix the seg fault.
+                // (i.e. if somebody runs this from the command line).
+                longjmp(g_jump_buffer, 1);
+            }
+            break;
+	}
+
+	// Reset the signal handler.
+	sig_t sig_result = signal (signo, signal_handler);
+	if (sig_result == SIG_ERR)
+	{
+		fprintf(stderr, "failed to set signal handler: errno=%d\n", errno);
+		exit (1);
+	}
+}
+
+static void
+swap_chars ()
+{
+    g_c1 = '1';
+    g_c2 = '0';
+
+    g_c1 = '0';
+    g_c2 = '1';
+}
+
+static void
+hello ()
+{
+    pthread_mutex_lock (&g_print_mutex);
+    printf ("hello, world\n");
+    pthread_mutex_unlock (&g_print_mutex);
+}
+
+static void*
+thread_func (void *arg)
+{
+	static pthread_mutex_t s_thread_index_mutex = PTHREAD_MUTEX_INITIALIZER;
+	static int s_thread_index = 1;
+
+	pthread_mutex_lock (&s_thread_index_mutex);
+	const int this_thread_index = s_thread_index++;
+	pthread_mutex_unlock (&s_thread_index_mutex);
+
+	if (g_print_thread_ids)
+	{
+		pthread_mutex_lock (&g_print_mutex);
+		printf ("thread %d id: ", this_thread_index);
+		print_thread_id ();
+		printf ("\n");
+		pthread_mutex_unlock (&g_print_mutex);
+	}
+
+	if (g_threads_do_segfault)
+	{
+		// Sleep for a number of seconds based on the thread index.
+		// TODO add ability to send commands to test exe so we can
+		// handle timing more precisely.  This is clunky.  All we're
+		// trying to do is add predictability as to the timing of
+		// signal generation by created threads.
+		int sleep_seconds = 2 * (this_thread_index - 1);
+		while (sleep_seconds > 0)
+			sleep_seconds = sleep(sleep_seconds);
+
+		// Test creating a SEGV.
+		pthread_mutex_lock (&g_jump_buffer_mutex);
+		g_is_segfaulting = true;
+		int *bad_p = nullptr;
+		if (setjmp(g_jump_buffer) == 0)
+		{
+			// Force a seg fault signal on this thread.
+			*bad_p = 0;
+		}
+		else
+		{
+			// Tell the system we're no longer seg faulting.
+			// Used by the SIGUSR1 signal handler that we inject
+			// in place of the SIGSEGV so it only tries to
+			// recover from the SIGSEGV if this seg fault code
+			// was in play.
+			g_is_segfaulting = false;
+		}
+		pthread_mutex_unlock (&g_jump_buffer_mutex);
+
+		pthread_mutex_lock (&g_print_mutex);
+		printf ("thread ");
+		print_thread_id ();
+		printf (": past SIGSEGV\n");
+		pthread_mutex_unlock (&g_print_mutex);
+	}
+
+	int sleep_seconds_remaining = 60;
+	while (sleep_seconds_remaining > 0)
+	{
+		sleep_seconds_remaining = sleep (sleep_seconds_remaining);
+	}
+
+	return nullptr;
+}
+
+int main (int argc, char **argv)
+{
+#if defined(__linux__)
+    // Immediately enable any ptracer so that we can allow the stub attach
+    // operation to succeed.  Some Linux kernels are locked down so that
+    // only an ancestor can be a ptracer of a process.  This disables that
+    // restriction.  Without it, attach-related stub tests will fail.
+#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY)
+    const int prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
+    static_cast<void> (prctl_result);
+#endif
+#endif
+
+	std::vector<pthread_t> threads;
+	std::unique_ptr<uint8_t[]> heap_array_up;
+    int return_value = 0;
+
+	// Set the signal handler.
+	sig_t sig_result = signal (SIGALRM, signal_handler);
+	if (sig_result == SIG_ERR)
+	{
+		fprintf(stderr, "failed to set SIGALRM signal handler: errno=%d\n", errno);
+		exit (1);
+	}
+
+	sig_result = signal (SIGUSR1, signal_handler);
+	if (sig_result == SIG_ERR)
+	{
+		fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
+		exit (1);
+	}
+
+	sig_result = signal (SIGSEGV, signal_handler);
+	if (sig_result == SIG_ERR)
+	{
+		fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
+		exit (1);
+	}
+
+	// Process command line args.
+    for (int i = 1; i < argc; ++i)
+    {
+        if (std::strstr (argv[i], STDERR_PREFIX))
+        {
+            // Treat remainder as text to go to stderr.
+            fprintf (stderr, "%s\n", (argv[i] + strlen (STDERR_PREFIX)));
+        }
+        else if (std::strstr (argv[i], RETVAL_PREFIX))
+        {
+            // Treat as the return value for the program.
+            return_value = std::atoi (argv[i] + strlen (RETVAL_PREFIX));
+        }
+        else if (std::strstr (argv[i], SLEEP_PREFIX))
+        {
+            // Treat as the amount of time to have this process sleep (in seconds).
+            int sleep_seconds_remaining = std::atoi (argv[i] + strlen (SLEEP_PREFIX));
+
+			// Loop around, sleeping until all sleep time is used up.  Note that
+			// signals will cause sleep to end early with the number of seconds remaining.
+			for (int i = 0; sleep_seconds_remaining > 0; ++i)
+			{
+				sleep_seconds_remaining = sleep (sleep_seconds_remaining);
+				// std::cout << "sleep result (call " << i << "): " << sleep_seconds_remaining << std::endl;
+			}
+        }
+		else if (std::strstr (argv[i], SET_MESSAGE_PREFIX))
+		{
+			// Copy the contents after "set-message:" to the g_message buffer.
+			// Used for reading inferior memory and verifying contents match expectations.
+            strncpy (g_message, argv[i] + strlen (SET_MESSAGE_PREFIX), sizeof (g_message));
+
+			// Ensure we're null terminated.
+			g_message[sizeof (g_message) - 1] = '\0';
+
+		}
+		else if (std::strstr (argv[i], PRINT_MESSAGE_COMMAND))
+		{
+			pthread_mutex_lock (&g_print_mutex);
+            printf ("message: %s\n", g_message);
+			pthread_mutex_unlock (&g_print_mutex);
+		}
+        else if (std::strstr (argv[i], GET_DATA_ADDRESS_PREFIX))
+        {
+            volatile void *data_p = nullptr;
+
+            if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_message"))
+                data_p = &g_message[0];
+            else if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_c1"))
+                data_p = &g_c1;
+            else if (std::strstr (argv[i] + strlen (GET_DATA_ADDRESS_PREFIX), "g_c2"))
+                data_p = &g_c2;
+
+			pthread_mutex_lock (&g_print_mutex);
+            printf ("data address: %p\n", data_p);
+			pthread_mutex_unlock (&g_print_mutex);
+        }
+        else if (std::strstr (argv[i], GET_HEAP_ADDRESS_COMMAND))
+        {
+			// Create a byte array if not already present.
+			if (!heap_array_up)
+				heap_array_up.reset (new uint8_t[32]);
+
+			pthread_mutex_lock (&g_print_mutex);
+            printf ("heap address: %p\n", heap_array_up.get ());
+			pthread_mutex_unlock (&g_print_mutex);
+        }
+        else if (std::strstr (argv[i], GET_STACK_ADDRESS_COMMAND))
+        {
+			pthread_mutex_lock (&g_print_mutex);
+            printf ("stack address: %p\n", &return_value);
+			pthread_mutex_unlock (&g_print_mutex);
+        }
+        else if (std::strstr (argv[i], GET_CODE_ADDRESS_PREFIX))
+        {
+            void (*func_p)() = nullptr;
+
+            if (std::strstr (argv[i] + strlen (GET_CODE_ADDRESS_PREFIX), "hello"))
+                func_p = hello;
+            else if (std::strstr (argv[i] + strlen (GET_CODE_ADDRESS_PREFIX), "swap_chars"))
+                func_p = swap_chars;
+
+			pthread_mutex_lock (&g_print_mutex);
+            printf ("code address: %p\n", func_p);
+			pthread_mutex_unlock (&g_print_mutex);
+        }
+        else if (std::strstr (argv[i], CALL_FUNCTION_PREFIX))
+        {
+            // Defaut to providing the address of main.
+            if (std::strcmp (argv[i] + strlen (CALL_FUNCTION_PREFIX), "hello") == 0)
+                hello();
+            else if (std::strcmp (argv[i] + strlen (CALL_FUNCTION_PREFIX), "swap_chars") == 0)
+                swap_chars();
+            else
+            {
+                pthread_mutex_lock (&g_print_mutex);
+                printf ("unknown function: %s\n", argv[i] + strlen (CALL_FUNCTION_PREFIX));
+                pthread_mutex_unlock (&g_print_mutex);
+            }
+        }
+		else if (std::strstr (argv[i], THREAD_PREFIX))
+		{
+			// Check if we're creating a new thread.
+			if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW))
+			{
+				// Create a new thread.
+				pthread_t new_thread;
+				const int err = ::pthread_create (&new_thread, nullptr, thread_func, nullptr);
+			    if (err)
+				{
+					fprintf (stderr, "pthread_create() failed with error code %d\n", err);
+					exit (err);
+				}
+				threads.push_back (new_thread);
+			}
+			else if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_PRINT_IDS))
+			{
+				// Turn on thread id announcing.
+				g_print_thread_ids = true;
+
+				// And announce us.
+				pthread_mutex_lock (&g_print_mutex);
+				printf ("thread 0 id: ");
+				print_thread_id ();
+				printf ("\n");
+				pthread_mutex_unlock (&g_print_mutex);
+			}
+			else if (std::strstr (argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_SEGFAULT))
+			{
+				g_threads_do_segfault = true;
+			}
+			else
+			{
+				// At this point we don't do anything else with threads.
+				// Later use thread index and send command to thread.
+			}
+		}
+        else
+        {
+            // Treat the argument as text for stdout.
+            printf("%s\n", argv[i]);
+        }
+    }
+
+	// If we launched any threads, join them
+	for (std::vector<pthread_t>::iterator it = threads.begin (); it != threads.end (); ++it)
+	{
+		void *thread_retval = nullptr;
+		const int err = ::pthread_join (*it, &thread_retval);
+	    if (err != 0)
+			fprintf (stderr, "pthread_join() failed with error code %d\n", err);
+	}
+    
+    return return_value;
+}