[apple/libpthread.git] / tests / stack.c

#include <signal.h>
#include <pthread/stack_np.h>

#include "darwintest_defaults.h"
#include <darwintest_utils.h>

#if defined(__arm64__)
#define call_chkstk(value) \
		__asm__ volatile("orr x9, xzr, %0\t\n" \
				"bl _thread_chkstk_darwin" : : "i"(value) : "x9")
#elif defined(__x86_64__)
#define call_chkstk(value) \
		__asm__ volatile("movq %0, %%rax\t\n" \
				"callq _thread_chkstk_darwin" : : "i"(value) : "rax")
#elif defined(__i386__)
#define call_chkstk(value) \
		__asm__ volatile("movl %0, %%eax\t\n" \
				"calll _thread_chkstk_darwin" : : "i"(value) : "eax")
#endif

static void
got_signal(int signo __unused)
{
	T_PASS("calling with 1 << 24 crashed");
	T_END;
}

T_DECL(chkstk, "chkstk",
		T_META_ALL_VALID_ARCHS(YES), T_META_CHECK_LEAKS(NO))
{
#if defined(__arm__)
	T_SKIP("not on armv7");
#else

	call_chkstk(1 << 8);
	T_PASS("calling with 1 << 8");

	call_chkstk(1 << 16);
	T_PASS("calling with 1 << 16");

	stack_t ss = {
		.ss_sp    = malloc(MINSIGSTKSZ),
		.ss_size  = MINSIGSTKSZ,
	};
	T_ASSERT_POSIX_SUCCESS(sigaltstack(&ss, NULL), "sigaltstack");

	struct sigaction sa = {
		.sa_handler = got_signal,
		.sa_flags = SA_ONSTACK,
	};
	T_ASSERT_POSIX_SUCCESS(sigaction(SIGSEGV, &sa, NULL), "sigaction");

#if __LP64__
	call_chkstk(1ul << 32);
#else
	call_chkstk(1ul << 24);
#endif
	T_FAIL("should have crashed");
#endif
}

struct frame {
	uintptr_t frame;
	uintptr_t ret;
};

OS_NOINLINE OS_NOT_TAIL_CALLED
static void
do_stack_frame_decode_test(struct frame frames[], size_t n, size_t count)
{
	if (n < count) {
		frames[n].frame = (uintptr_t)__builtin_frame_address(1);
		frames[n].ret = (uintptr_t)__builtin_return_address(0);
		do_stack_frame_decode_test(frames, n + 1, count);
	} else {
		uintptr_t frame = (uintptr_t)__builtin_frame_address(1);
		uintptr_t ret;
		while (count-- > 0) {
			frame = pthread_stack_frame_decode_np(frame, &ret);
			T_EXPECT_EQ(frames[count].frame, frame, "Frame %zd", count);
			T_EXPECT_EQ(frames[count].ret, ret, "Retaddr %zd", count);
		}
	}
}

T_DECL(pthread_stack_frame_decode_np, "pthread_stack_frame_decode_np",
		T_META_ALL_VALID_ARCHS(YES), T_META_CHECK_LEAKS(NO))
{
	struct frame frames[10];
	frames[0].frame = (uintptr_t)__builtin_frame_address(1);
	frames[0].ret = (uintptr_t)__builtin_return_address(0);
	do_stack_frame_decode_test(frames, 1, 10);
}
Commit	Line	Data
214d78a2 A	1	#include <signal.h>
	2	#include <pthread/stack_np.h>
	3
	4	#include "darwintest_defaults.h"
	5	#include <darwintest_utils.h>
	6
	7	#if defined(__arm64__)
	8	#define call_chkstk(value) \
	9	__asm__ volatile("orr x9, xzr, %0\t\n" \
	10	"bl _thread_chkstk_darwin" : : "i"(value) : "x9")
214d78a2 A	11	#elif defined(__x86_64__)
	12	#define call_chkstk(value) \
	13	__asm__ volatile("movq %0, %%rax\t\n" \
	14	"callq _thread_chkstk_darwin" : : "i"(value) : "rax")
214d78a2 A	15	#elif defined(__i386__)
	16	#define call_chkstk(value) \
	17	__asm__ volatile("movl %0, %%eax\t\n" \
	18	"calll _thread_chkstk_darwin" : : "i"(value) : "eax")
214d78a2 A	19	#endif
	20
	21	static void
	22	got_signal(int signo __unused)
	23	{
	24	T_PASS("calling with 1 << 24 crashed");
	25	T_END;
	26	}
	27
	28	T_DECL(chkstk, "chkstk",
	29	T_META_ALL_VALID_ARCHS(YES), T_META_CHECK_LEAKS(NO))
	30	{
	31	#if defined(__arm__)
	32	T_SKIP("not on armv7");
	33	#else
	34
	35	call_chkstk(1 << 8);
	36	T_PASS("calling with 1 << 8");
	37
	38	call_chkstk(1 << 16);
	39	T_PASS("calling with 1 << 16");
	40
c6e5f90c A	41	stack_t ss = {
	42	.ss_sp = malloc(MINSIGSTKSZ),
	43	.ss_size = MINSIGSTKSZ,
	44	};
	45	T_ASSERT_POSIX_SUCCESS(sigaltstack(&ss, NULL), "sigaltstack");
	46
	47	struct sigaction sa = {
	48	.sa_handler = got_signal,
	49	.sa_flags = SA_ONSTACK,
	50	};
	51	T_ASSERT_POSIX_SUCCESS(sigaction(SIGSEGV, &sa, NULL), "sigaction");
214d78a2	52
45deb508 A	53	#if __LP64__
	54	call_chkstk(1ul << 32);
	55	#else
	56	call_chkstk(1ul << 24);
	57	#endif
214d78a2 A	58	T_FAIL("should have crashed");
	59	#endif
	60	}
	61
	62	struct frame {
	63	uintptr_t frame;
	64	uintptr_t ret;
	65	};
	66
	67	OS_NOINLINE OS_NOT_TAIL_CALLED
	68	static void
	69	do_stack_frame_decode_test(struct frame frames[], size_t n, size_t count)
	70	{
	71	if (n < count) {
	72	frames[n].frame = (uintptr_t)__builtin_frame_address(1);
	73	frames[n].ret = (uintptr_t)__builtin_return_address(0);
	74	do_stack_frame_decode_test(frames, n + 1, count);
	75	} else {
	76	uintptr_t frame = (uintptr_t)__builtin_frame_address(1);
	77	uintptr_t ret;
	78	while (count-- > 0) {
	79	frame = pthread_stack_frame_decode_np(frame, &ret);
	80	T_EXPECT_EQ(frames[count].frame, frame, "Frame %zd", count);
	81	T_EXPECT_EQ(frames[count].ret, ret, "Retaddr %zd", count);
	82	}
	83	}
	84	}
	85
	86	T_DECL(pthread_stack_frame_decode_np, "pthread_stack_frame_decode_np",
	87	T_META_ALL_VALID_ARCHS(YES), T_META_CHECK_LEAKS(NO))
	88	{
	89	struct frame frames[10];
	90	frames[0].frame = (uintptr_t)__builtin_frame_address(1);
	91	frames[0].ret = (uintptr_t)__builtin_return_address(0);
	92	do_stack_frame_decode_test(frames, 1, 10);
	93	}