lib: Add mlibc

Signed-off-by: Ian Moffett <ian@osmora.org>

51 files changed, 813 insertions, 0 deletions

diff --git a/lib/mlibc/tests/rtdl/dl_iterate_phdr/libbar.c b/lib/mlibc/tests/rtdl/dl_iterate_phdr/libbar.c
new file mode 100644
index 0000000..41ccc56
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/dl_iterate_phdr/libbar.c
@@ -0,0 +1,3 @@
+// Bar needs to have a relocation against foo in order to set DT_NEEDED.
+int foo(void);
+int bar() { return foo(); }
diff --git a/lib/mlibc/tests/rtdl/dl_iterate_phdr/libfoo.c b/lib/mlibc/tests/rtdl/dl_iterate_phdr/libfoo.c
new file mode 100644
index 0000000..9fe07f8
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/dl_iterate_phdr/libfoo.c
@@ -0,0 +1 @@
+int foo() { return 0; }
diff --git a/lib/mlibc/tests/rtdl/dl_iterate_phdr/meson.build b/lib/mlibc/tests/rtdl/dl_iterate_phdr/meson.build
new file mode 100644
index 0000000..acb679e
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/dl_iterate_phdr/meson.build
@@ -0,0 +1,7 @@
+libfoo = shared_library('foo', 'libfoo.c')
+libbar = shared_library('bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo)
+test_depends = [libfoo, libbar]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c', native: true)
+libbar_native = shared_library('native-bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo_native, native: true)
+test_native_depends = [libfoo_native, libbar_native]
diff --git a/lib/mlibc/tests/rtdl/dl_iterate_phdr/test.c b/lib/mlibc/tests/rtdl/dl_iterate_phdr/test.c
new file mode 100644
index 0000000..5d48a41
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/dl_iterate_phdr/test.c
@@ -0,0 +1,91 @@
+#include <assert.h>
+#include <link.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <stdio.h>
+
+#ifdef USE_HOST_LIBC
+#define LDSO_PATTERN "ld-linux-"
+#define LIBFOO "libnative-foo.so"
+#define LIBBAR "libnative-bar.so"
+#else
+#define LDSO_PATTERN "ld.so"
+#define LIBFOO "libfoo.so"
+#define LIBBAR "libbar.so"
+#endif
+
+struct result {
+	int found_ldso;
+	int found_self;
+	int found_foo;
+	int found_bar;
+};
+
+static int ends_with(const char *suffix, const char *s) {
+	size_t suffix_len = strlen(suffix);
+	size_t s_len = strlen(s);
+	if (s_len < suffix_len)
+		return 0;
+	else {
+		return !strcmp(suffix, s + s_len - suffix_len);
+	}
+}
+
+static int contains(const char *pattern, const char *s) {
+	return !!strstr(s, pattern);
+}
+
+static int callback(struct dl_phdr_info *info, size_t size, void *data) {
+	assert(size == sizeof(struct dl_phdr_info));
+	struct result *found = (struct result *) data;
+
+	printf("%s\n", info->dlpi_name);
+	fflush(stdout);
+
+	if (ends_with("foo.so", info->dlpi_name))
+		found->found_foo++;
+	if (ends_with("bar.so", info->dlpi_name))
+		found->found_bar++;
+	if (contains(LDSO_PATTERN, info->dlpi_name))
+		found->found_ldso++;
+
+	if (!strcmp("", info->dlpi_name))
+		found->found_self++;
+
+	assert(info->dlpi_phdr);
+	return 0;
+}
+
+int main() {
+	struct result found = { 0 };
+	assert(!dl_iterate_phdr(callback, &found));
+	assert(found.found_ldso == 1);
+	assert(found.found_self == 1);
+	assert(found.found_foo == 0);
+	assert(found.found_bar == 0);
+	printf("---\n");
+
+	memset(&found, 0, sizeof(found));
+	void *bar = dlopen(LIBBAR, RTLD_LOCAL | RTLD_NOW);
+	assert(bar);
+	assert(!dl_iterate_phdr(callback, &found));
+	assert(found.found_ldso == 1);
+	assert(found.found_self == 1);
+	assert(found.found_bar == 1);
+	assert(found.found_foo == 1); // Since bar depends on foo.
+	printf("---\n");
+
+	memset(&found, 0, sizeof(found));
+	void *foo = dlopen(LIBFOO, RTLD_GLOBAL | RTLD_NOW);
+	assert(foo);
+	assert(!dl_iterate_phdr(callback, &found));
+	assert(found.found_ldso == 1);
+	assert(found.found_self == 1);
+	assert(found.found_foo == 1);
+	assert(found.found_bar == 1);
+	printf("---\n");
+
+	dlclose(bar);
+	dlclose(foo);
+	return 0;
+}
diff --git a/lib/mlibc/tests/rtdl/dladdr_local/libfoo.c b/lib/mlibc/tests/rtdl/dladdr_local/libfoo.c
new file mode 100644
index 0000000..2903a3d
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/dladdr_local/libfoo.c
@@ -0,0 +1 @@
+char foo_global[] = "";
diff --git a/lib/mlibc/tests/rtdl/dladdr_local/meson.build b/lib/mlibc/tests/rtdl/dladdr_local/meson.build
new file mode 100644
index 0000000..4ae6bb3
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/dladdr_local/meson.build
@@ -0,0 +1,5 @@
+libfoo = shared_library('foo', 'libfoo.c')
+test_depends = [libfoo]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c', native: true)
+test_native_depends = [libfoo_native]
diff --git a/lib/mlibc/tests/rtdl/dladdr_local/test.c b/lib/mlibc/tests/rtdl/dladdr_local/test.c
new file mode 100644
index 0000000..c64d259
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/dladdr_local/test.c
@@ -0,0 +1,21 @@
+#include <dlfcn.h>
+#include <assert.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBFOO "libnative-foo.so"
+#else
+#define LIBFOO "libfoo.so"
+#endif
+
+int main() {
+	void *foo_handle = dlopen(LIBFOO, RTLD_LOCAL | RTLD_NOW);
+	assert(foo_handle);
+	
+	char *foo_global = (char *)dlsym(foo_handle, "foo_global");
+	assert(foo_global);
+	
+	Dl_info info;
+	assert(dladdr((const void *)foo_global, &info) != 0);
+	
+	assert(dlclose(foo_handle) == 0);
+}
diff --git a/lib/mlibc/tests/rtdl/ld_library_path/libfoo.c b/lib/mlibc/tests/rtdl/ld_library_path/libfoo.c
new file mode 100644
index 0000000..85e6cd8
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/ld_library_path/libfoo.c
@@ -0,0 +1 @@
+void foo() {}
diff --git a/lib/mlibc/tests/rtdl/ld_library_path/meson.build b/lib/mlibc/tests/rtdl/ld_library_path/meson.build
new file mode 100644
index 0000000..95629be
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/ld_library_path/meson.build
@@ -0,0 +1,19 @@
+# Remove the RPATH and set the LD_LIBRARY_PATH environment variable
+# instead when running tests to make sure the library can be found
+# in a directory specified by the user at runtime
+
+test_rpath = '$ORIGIN/'
+
+test_ld_path = meson.build_root() / 'tests' / 'rtdl' / test_name
+test_env += ['LD_LIBRARY_PATH=' + test_ld_path]
+test_native_env += ['LD_LIBRARY_PATH=' + test_ld_path]
+
+libfoo = shared_library('foo', 'libfoo.c',
+	dependencies: libc_dep,
+	link_args: test_additional_link_args,
+)
+
+libfoo_native = shared_library('native-foo', 'libfoo.c',
+	link_args: ['-ldl'] + test_additional_link_args,
+	native: true
+)
diff --git a/lib/mlibc/tests/rtdl/ld_library_path/test.c b/lib/mlibc/tests/rtdl/ld_library_path/test.c
new file mode 100644
index 0000000..15ca200
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/ld_library_path/test.c
@@ -0,0 +1,16 @@
+#include <dlfcn.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBFOO "libnative-foo.so"
+#else
+#define LIBFOO "libfoo.so"
+#endif
+
+int main() {
+	void *foo = dlopen(LIBFOO, RTLD_NOW);
+	assert(foo);
+	dlclose(foo);
+}
diff --git a/lib/mlibc/tests/rtdl/meson.build b/lib/mlibc/tests/rtdl/meson.build
new file mode 100644
index 0000000..1331899
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/meson.build
@@ -0,0 +1,56 @@
+rtdl_test_cases = [
+	'dl_iterate_phdr',
+	'dladdr_local',
+	'ld_library_path',
+	'noload-promote',
+	'rtld_next',
+	'soname',
+	'preinit',
+	'scope1',
+	'scope2',
+	'scope3',
+	'scope4',
+	'scope5',
+	'tls_align',
+]
+
+foreach test_name : rtdl_test_cases 
+	test_rpath = meson.build_root() / 'tests' / 'rtdl' / test_name / ''
+	test_rpath += ':$ORIGIN/' # Workaround old and buggy qemu-user on CI
+
+	test_env = []
+	test_link_with = []
+	test_depends = []
+	test_native_env = []
+	test_native_link_with = []
+	test_native_depends = []
+	test_additional_link_args = []
+
+	# Build the needed DSOs for the test. This sets the variables above.
+	subdir(test_name)
+
+	exec = executable('rtdl-' + test_name, [test_name / 'test.c', test_sources],
+		link_with: test_link_with,
+		dependencies: libc_dep,
+		build_rpath: test_rpath,
+		override_options: test_override_options,
+		c_args: test_c_args,
+		link_args: test_link_args + test_additional_link_args,
+	)
+	test(test_name, exec, env: test_env, suite: 'rtdl', depends: test_depends)
+
+	if build_tests_host_libc and not host_libc_excluded_test_cases.contains(test_name)
+		exec = executable('host-libc-' + test_name, test_name / 'test.c',
+			link_with: test_native_link_with,
+			dependencies: rtlib_deps,
+			build_rpath: test_rpath,
+			# Don't use ASan here, due to a bug that breaks dlopen() + DT_RUNPATH:
+			# https://bugzilla.redhat.com/show_bug.cgi?id=1449604
+			override_options: 'b_sanitize=undefined',
+			c_args: ['-D_GNU_SOURCE', '-DUSE_HOST_LIBC'],
+			link_args: ['-ldl'] + test_additional_link_args,
+			native: true,
+		)
+		test(test_name, exec, env: test_native_env, suite: ['host-libc', 'rtdl'], depends: test_native_depends)
+	endif
+endforeach
diff --git a/lib/mlibc/tests/rtdl/noload-promote/libfoo.c b/lib/mlibc/tests/rtdl/noload-promote/libfoo.c
new file mode 100644
index 0000000..85e6cd8
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/noload-promote/libfoo.c
@@ -0,0 +1 @@
+void foo() {}
diff --git a/lib/mlibc/tests/rtdl/noload-promote/meson.build b/lib/mlibc/tests/rtdl/noload-promote/meson.build
new file mode 100644
index 0000000..4ae6bb3
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/noload-promote/meson.build
@@ -0,0 +1,5 @@
+libfoo = shared_library('foo', 'libfoo.c')
+test_depends = [libfoo]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c', native: true)
+test_native_depends = [libfoo_native]
diff --git a/lib/mlibc/tests/rtdl/noload-promote/test.c b/lib/mlibc/tests/rtdl/noload-promote/test.c
new file mode 100644
index 0000000..0a6c55c
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/noload-promote/test.c
@@ -0,0 +1,22 @@
+#include <dlfcn.h>
+#include <assert.h>
+#include <stddef.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBFOO "libnative-foo.so"
+#else
+#define LIBFOO "libfoo.so"
+#endif
+
+int main() {
+	void *foo = dlopen(LIBFOO, RTLD_LOCAL | RTLD_NOW);
+	assert(foo);
+
+	assert(dlsym(RTLD_DEFAULT, "foo") == NULL);
+
+	// Opening a library with RTLD_NOLOAD | RTLD_GLOBAL should promote it to the global scope.
+	assert(dlopen(LIBFOO, RTLD_NOLOAD | RTLD_GLOBAL | RTLD_NOW) == foo);
+	assert(dlsym(RTLD_DEFAULT, "foo") != NULL);
+	
+	assert(dlopen("does-not-exist.so.1337", RTLD_NOLOAD | RTLD_GLOBAL | RTLD_NOW) == NULL);
+}
diff --git a/lib/mlibc/tests/rtdl/preinit/libfoo.c b/lib/mlibc/tests/rtdl/preinit/libfoo.c
new file mode 100644
index 0000000..9c834ea
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/preinit/libfoo.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <assert.h>
+
+int fooDone = 0;
+
+// DSOs do not support pre-initialization functions.
+
+__attribute__((constructor))
+void fooInit() {
+	dprintf(1, "initialization function called in foo\n");
+
+	assert(fooDone == 0);
+	fooDone++;
+}
+
+int isFooDone() {
+	return fooDone;
+}
diff --git a/lib/mlibc/tests/rtdl/preinit/meson.build b/lib/mlibc/tests/rtdl/preinit/meson.build
new file mode 100644
index 0000000..1a7f398
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/preinit/meson.build
@@ -0,0 +1,18 @@
+if host_machine.cpu_family() == 'riscv64'
+	# gp isn't initialized until after crt1.o runs, so to access
+	# globals in our pre-initializers we must disable it.
+	test_additional_link_args = ['-Wl,--no-relax']
+endif
+
+libfoo = shared_library('foo', 'libfoo.c',
+	dependencies: libc_dep,
+	override_options: 'b_sanitize=none',
+	link_args: test_additional_link_args,
+)
+test_link_with = [libfoo]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c',
+	link_args: ['-ldl'] + test_additional_link_args,
+	native: true
+)
+test_native_link_with = [libfoo_native]
diff --git a/lib/mlibc/tests/rtdl/preinit/test.c b/lib/mlibc/tests/rtdl/preinit/test.c
new file mode 100644
index 0000000..5b5d5e8
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/preinit/test.c
@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <assert.h>
+
+int mainDone = 0;
+
+int isFooDone();
+
+void preInit1() {
+	// Use dprintf because stdout might not be initialized yet.
+	dprintf(1, "pre-initialization function 1 called in main executable\n");
+
+	assert(isFooDone() == 0);
+	assert(mainDone == 0);
+	mainDone++;
+}
+
+void preInit2() {
+	dprintf(1, "pre-initialization function 2 called in main executable\n");
+
+	assert(isFooDone() == 0);
+	assert(mainDone == 1);
+	mainDone++;
+}
+
+__attribute__((constructor))
+void mainInit() {
+	dprintf(1, "initialization function called in main executable\n");
+
+	assert(isFooDone() == 1);
+	assert(mainDone == 2);
+	mainDone++;
+}
+
+// Manually register the pre-initialization functions.
+__attribute__((used, section(".preinit_array")))
+static void (*preinitFunctions[])(void) = {
+	&preInit1,
+	&preInit2,
+};
+
+int main() {
+	assert(isFooDone() == 1);
+	assert(mainDone == 3);
+}
diff --git a/lib/mlibc/tests/rtdl/rtld_next/libbar.c b/lib/mlibc/tests/rtdl/rtld_next/libbar.c
new file mode 100644
index 0000000..c0950c5
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/rtld_next/libbar.c
@@ -0,0 +1,16 @@
+#include <dlfcn.h>
+
+typedef char *charFn(void);
+
+__attribute__((weak))
+char *definedInBoth() {
+	return "bar";
+}
+
+charFn *barGetDefault() {
+	return (charFn *)dlsym(RTLD_DEFAULT, "definedInBoth");
+}
+
+charFn *barGetNext() {
+	return (charFn *)dlsym(RTLD_NEXT, "definedInBoth");
+}
diff --git a/lib/mlibc/tests/rtdl/rtld_next/libfoo.c b/lib/mlibc/tests/rtdl/rtld_next/libfoo.c
new file mode 100644
index 0000000..1d46b73
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/rtld_next/libfoo.c
@@ -0,0 +1,17 @@
+#include <dlfcn.h>
+
+typedef char *charFn(void);
+
+__attribute__((weak))
+char *definedInBoth() {
+	return "foo";
+}
+
+charFn *fooGetDefault() {
+	return (charFn *)dlsym(RTLD_DEFAULT, "definedInBoth");
+}
+
+charFn *fooGetNext() {
+	return (charFn *)dlsym(RTLD_NEXT, "definedInBoth");
+}
+
diff --git a/lib/mlibc/tests/rtdl/rtld_next/meson.build b/lib/mlibc/tests/rtdl/rtld_next/meson.build
new file mode 100644
index 0000000..d156c24
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/rtld_next/meson.build
@@ -0,0 +1,25 @@
+# Prevent tail calls, as it breaks libc's 'calling object' detection.
+no_tail_calls = '-fno-optimize-sibling-calls'
+
+libfoo = shared_library('foo', 'libfoo.c',
+	dependencies: libc_dep,
+	c_args: no_tail_calls,
+)
+libbar = shared_library('bar', 'libbar.c',
+	dependencies: libc_dep,
+	c_args: no_tail_calls,
+)
+test_link_with = [libfoo, libbar] # foo is linked before bar
+
+libfoo_native = shared_library('native-foo', 'libfoo.c',
+	c_args: [no_tail_calls, '-D_GNU_SOURCE'],
+	link_args: '-ldl',
+	native: true
+)
+libbar_native = shared_library('native-bar', 'libbar.c',
+	c_args: [no_tail_calls, '-D_GNU_SOURCE'],
+	link_args: '-ldl',
+	native: true
+)
+test_native_link_with = [libfoo_native, libbar_native]
+
diff --git a/lib/mlibc/tests/rtdl/rtld_next/test.c b/lib/mlibc/tests/rtdl/rtld_next/test.c
new file mode 100644
index 0000000..3e90a63
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/rtld_next/test.c
@@ -0,0 +1,26 @@
+#include <string.h>
+#include <assert.h>
+
+typedef char *charFn(void);
+charFn *fooGetDefault(void);
+charFn *fooGetNext(void);
+charFn *barGetDefault(void);
+charFn *barGetNext(void);
+
+int main() {
+	charFn *ret;
+
+	ret = fooGetDefault();
+	assert(ret != NULL);
+	assert(!strcmp(ret(), "foo"));
+
+	ret = fooGetNext();
+	assert(ret != NULL);
+	assert(!strcmp(ret(), "bar"));
+
+	ret = barGetDefault();
+	assert(ret != NULL);
+	assert(!strcmp(ret(), "foo"));
+
+	assert(barGetNext() == NULL);
+}
diff --git a/lib/mlibc/tests/rtdl/scope1/libbar.c b/lib/mlibc/tests/rtdl/scope1/libbar.c
new file mode 100644
index 0000000..ecf043e
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope1/libbar.c
@@ -0,0 +1,14 @@
+char *foo(void);
+char *foo_global(void);
+
+char *bar() {
+	return "bar";
+}
+
+char *bar_calls_foo() {
+	return foo();
+}
+
+char *bar_calls_foo_global() {
+	return foo_global();
+}
diff --git a/lib/mlibc/tests/rtdl/scope1/libfoo.c b/lib/mlibc/tests/rtdl/scope1/libfoo.c
new file mode 100644
index 0000000..b4e1b8c
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope1/libfoo.c
@@ -0,0 +1,9 @@
+char *foo() {
+	return "foo";
+}
+
+char global[] = "foo global";
+
+char *foo_global() {
+	return global;
+}
diff --git a/lib/mlibc/tests/rtdl/scope1/meson.build b/lib/mlibc/tests/rtdl/scope1/meson.build
new file mode 100644
index 0000000..acb679e
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope1/meson.build
@@ -0,0 +1,7 @@
+libfoo = shared_library('foo', 'libfoo.c')
+libbar = shared_library('bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo)
+test_depends = [libfoo, libbar]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c', native: true)
+libbar_native = shared_library('native-bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo_native, native: true)
+test_native_depends = [libfoo_native, libbar_native]
diff --git a/lib/mlibc/tests/rtdl/scope1/test.c b/lib/mlibc/tests/rtdl/scope1/test.c
new file mode 100644
index 0000000..c19915d
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope1/test.c
@@ -0,0 +1,90 @@
+#include <stddef.h>
+#include <dlfcn.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBFOO "libnative-foo.so"
+#define LIBBAR "libnative-bar.so"
+#else
+#define LIBFOO "libfoo.so"
+#define LIBBAR "libbar.so"
+#endif
+
+typedef char *strfn(void);
+
+int main() {
+	// We haven't dlopen'd these libs yet, so symbol resolution should fail.
+	assert(dlsym(RTLD_DEFAULT, "foo") == NULL);
+	assert(dlsym(RTLD_DEFAULT, "bar") == NULL);
+
+	assert(!dlopen(LIBFOO, RTLD_NOLOAD));
+	assert(!dlopen(LIBBAR, RTLD_NOLOAD));
+
+	void *foo_handle = dlopen(LIBFOO, RTLD_LOCAL | RTLD_NOW);
+	assert(foo_handle);
+	assert(dlopen(LIBFOO, RTLD_NOLOAD | RTLD_NOW));
+
+	strfn *foo_sym = dlsym(foo_handle, "foo");
+	assert(foo_sym);
+	assert(foo_sym());
+	assert(!strcmp(foo_sym(), "foo"));
+
+	strfn *foo_global_sym = dlsym(foo_handle, "foo_global");
+	assert(foo_global_sym);
+	assert(foo_global_sym());
+	assert(!strcmp(foo_global_sym(), "foo global"));
+
+	assert(dlsym(foo_handle, "doesnotexist") == NULL);
+
+	// Nested opening should work
+	assert(dlopen(LIBFOO, RTLD_LOCAL | RTLD_NOW) == foo_handle);
+	assert(dlopen(LIBFOO, RTLD_NOLOAD | RTLD_NOW));
+
+	// Since we've loaded the same library twice, the addresses should be the same
+	assert(dlsym(foo_handle, "foo") == foo_sym);
+	assert(dlsym(foo_handle, "foo_global") == foo_global_sym);
+
+	// libfoo was opened with RTLD_LOCAL, so we shouldn't be able to lookup
+	// its symbols in the global namespace.
+	assert(dlsym(RTLD_DEFAULT, "foo") == NULL);
+
+	{
+		void *bar_handle = dlopen(LIBBAR, RTLD_GLOBAL | RTLD_NOW);
+		assert(bar_handle);
+		assert(dlopen(LIBBAR, RTLD_NOLOAD | RTLD_NOW));
+		
+		strfn *bar_sym = dlsym(bar_handle, "bar");
+		assert(bar_sym);
+		assert(bar_sym());
+		assert(!strcmp(bar_sym(), "bar"));
+		
+		strfn *bar_calls_foo_sym = dlsym(bar_handle, "bar_calls_foo");
+		assert(bar_calls_foo_sym);
+		assert(bar_calls_foo_sym());
+		assert(!strcmp(bar_calls_foo_sym(), "foo"));
+		
+		strfn *bar_calls_foo_global_sym = dlsym(bar_handle, "bar_calls_foo_global");
+		assert(bar_calls_foo_global_sym);
+		assert(bar_calls_foo_global_sym());
+		assert(!strcmp(bar_calls_foo_global_sym(), "foo global"));
+
+		// libbar was opened with RTLD_GLOBAL, so we can find symbols by
+		// searching in the global scope.
+		strfn *new_bar_sym = dlsym(RTLD_DEFAULT, "bar");
+		assert(new_bar_sym);
+		assert(new_bar_sym == bar_sym);
+
+		// Note that we loaded libbar with RTLD_GLOBAL, which should pull
+		// in libfoo's symbols globally too.
+		strfn *new_foo_sym = dlsym(RTLD_DEFAULT, "foo");
+		assert(new_foo_sym);
+		assert(new_foo_sym == foo_sym);
+
+		assert(dlclose(bar_handle) == 0);
+	}
+
+	assert(dlclose(foo_handle) == 0);
+	assert(dlclose(foo_handle) == 0);
+}
diff --git a/lib/mlibc/tests/rtdl/scope2/libbar.c b/lib/mlibc/tests/rtdl/scope2/libbar.c
new file mode 100644
index 0000000..4783c58
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope2/libbar.c
@@ -0,0 +1,5 @@
+char *foo_baz_conflict(void);
+
+char *bar_calls_foo_baz_conflict() {
+	return foo_baz_conflict();
+}
diff --git a/lib/mlibc/tests/rtdl/scope2/libbaz.c b/lib/mlibc/tests/rtdl/scope2/libbaz.c
new file mode 100644
index 0000000..fc73adc
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope2/libbaz.c
@@ -0,0 +1,3 @@
+char *foo_baz_conflict() {
+	return "resolved to baz";
+}
diff --git a/lib/mlibc/tests/rtdl/scope2/libfoo.c b/lib/mlibc/tests/rtdl/scope2/libfoo.c
new file mode 100644
index 0000000..9f7b881
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope2/libfoo.c
@@ -0,0 +1,3 @@
+char *foo_baz_conflict() {
+	return "resolved to foo";
+}
diff --git a/lib/mlibc/tests/rtdl/scope2/meson.build b/lib/mlibc/tests/rtdl/scope2/meson.build
new file mode 100644
index 0000000..938272c
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope2/meson.build
@@ -0,0 +1,9 @@
+libfoo = shared_library('foo', 'libfoo.c')
+libbar = shared_library('bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo)
+libbaz = shared_library('baz', 'libbaz.c')
+test_depends = [libfoo, libbar, libbaz]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c', native: true)
+libbar_native = shared_library('native-bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo_native, native: true)
+libbaz_native = shared_library('native-baz', 'libbaz.c', native: true)
+test_native_depends = [libfoo_native, libbar_native, libbaz_native]
diff --git a/lib/mlibc/tests/rtdl/scope2/test.c b/lib/mlibc/tests/rtdl/scope2/test.c
new file mode 100644
index 0000000..f4f42dc
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope2/test.c
@@ -0,0 +1,36 @@
+#include <stddef.h>
+#include <dlfcn.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBBAR "libnative-bar.so"
+#define LIBBAZ "libnative-baz.so"
+#else
+#define LIBBAR "libbar.so"
+#define LIBBAZ "libbaz.so"
+#endif
+
+typedef char *strfn(void);
+
+int main() {
+	void *baz = dlopen(LIBBAZ, RTLD_LAZY | RTLD_GLOBAL);
+	assert(baz);
+
+	// At this point, baz is loaded in the global scope. When we load bar locally,
+	// there is a relocation to `foo_baz_conflict` which is defined in both
+	// foo (which is a dependency of bar), and baz. In this case baz should win
+	// since we search the global scope first.
+
+	void *bar = dlopen(LIBBAR, RTLD_LAZY | RTLD_LOCAL);
+	assert(bar);
+
+	strfn *bfn = dlsym(bar, "bar_calls_foo_baz_conflict");
+	assert(!strcmp(bfn(), "resolved to baz"));
+
+	// TODO: Test RTLD_DEEPBIND and DT_SYMBOLIC once we implement it.
+
+	dlclose(bar);
+	dlclose(baz);
+}
diff --git a/lib/mlibc/tests/rtdl/scope3/libbar.c b/lib/mlibc/tests/rtdl/scope3/libbar.c
new file mode 100644
index 0000000..dc377b6
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope3/libbar.c
@@ -0,0 +1,8 @@
+int g = 1;
+
+int call_foo();
+
+int call_bar() {
+	return call_foo();
+}
+
diff --git a/lib/mlibc/tests/rtdl/scope3/libbaz.c b/lib/mlibc/tests/rtdl/scope3/libbaz.c
new file mode 100644
index 0000000..32524cc
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope3/libbaz.c
@@ -0,0 +1,7 @@
+int g = 2;
+
+int call_foo();
+
+int call_baz() {
+	return call_foo();
+}
diff --git a/lib/mlibc/tests/rtdl/scope3/libfoo.c b/lib/mlibc/tests/rtdl/scope3/libfoo.c
new file mode 100644
index 0000000..bc86319
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope3/libfoo.c
@@ -0,0 +1,5 @@
+int g = 0;
+
+int call_foo() {
+	return g;
+}
diff --git a/lib/mlibc/tests/rtdl/scope3/meson.build b/lib/mlibc/tests/rtdl/scope3/meson.build
new file mode 100644
index 0000000..0c98583
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope3/meson.build
@@ -0,0 +1,9 @@
+libfoo = shared_library('foo', 'libfoo.c')
+libbar = shared_library('bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo)
+libbaz = shared_library('baz', 'libbaz.c', build_rpath: test_rpath, link_with: libfoo)
+test_depends = [libfoo, libbar, libbaz]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c', native: true)
+libbar_native = shared_library('native-bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo_native, native: true)
+libbaz_native = shared_library('native-baz', 'libbaz.c', build_rpath: test_rpath, link_with: libfoo_native, native: true)
+test_native_depends = [libfoo_native, libbar_native, libbaz_native]
diff --git a/lib/mlibc/tests/rtdl/scope3/test.c b/lib/mlibc/tests/rtdl/scope3/test.c
new file mode 100644
index 0000000..30fc662
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope3/test.c
@@ -0,0 +1,39 @@
+#include <dlfcn.h>
+#include <stdio.h>
+#include <assert.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBBAR "libnative-bar.so"
+#define LIBBAZ "libnative-baz.so"
+#else
+#define LIBBAR "libbar.so"
+#define LIBBAZ "libbaz.so"
+#endif
+
+int main() {
+	// In this test, we have bar -> foo and baz -> foo (where -> means 'depends on').
+	// All three objects contain a definition of a symbol g. Bar calls into foo to retrieve
+	// what foo thinks g is, but since bar appears earlier in the scope than foo, bar's copy
+	// of g wins.
+	//
+	// Next, we load baz, which is identical to bar. When baz calls into foo to retrieve g,
+	// foo still sees bar's definition of g, so bar's copy of g wins.
+	//
+	// Swapping the load order of bar and baz should therefore change the value of g which
+	// foo sees. This behaviour is why dlmopen exists. If we ever implement that, we should
+	// write a similar test and assert that the calls return different results.
+
+	void *libbar = dlopen(LIBBAR, RTLD_LAZY | RTLD_LOCAL);
+	int (*call_bar)(void) = dlsym(libbar, "call_bar");
+	printf("call_bar: %d\n", call_bar());
+	assert(call_bar() == 1);
+
+	void *libbaz = dlopen(LIBBAZ, RTLD_LAZY | RTLD_LOCAL);
+	int (*call_baz)(void) = dlsym(libbaz, "call_baz");
+	printf("call_baz: %d\n", call_baz());
+	assert(call_baz() == 1);
+
+
+	dlclose(libbar);
+	dlclose(libbaz);
+}
diff --git a/lib/mlibc/tests/rtdl/scope4/libbar.c b/lib/mlibc/tests/rtdl/scope4/libbar.c
new file mode 100644
index 0000000..514e456
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope4/libbar.c
@@ -0,0 +1,3 @@
+// Bar needs to have a relocation against foo in order to set DT_NEEDED.
+void foo(void);
+void bar() { foo(); }
diff --git a/lib/mlibc/tests/rtdl/scope4/libbaz.c b/lib/mlibc/tests/rtdl/scope4/libbaz.c
new file mode 100644
index 0000000..256a0e3
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope4/libbaz.c
@@ -0,0 +1 @@
+void baz() {}
diff --git a/lib/mlibc/tests/rtdl/scope4/libfoo.c b/lib/mlibc/tests/rtdl/scope4/libfoo.c
new file mode 100644
index 0000000..6710db7
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope4/libfoo.c
@@ -0,0 +1,3 @@
+// Foo needs to have a relocation against baz in order to set DT_NEEDED.
+void baz(void);
+void foo() { baz(); }
diff --git a/lib/mlibc/tests/rtdl/scope4/meson.build b/lib/mlibc/tests/rtdl/scope4/meson.build
new file mode 100644
index 0000000..804a40c
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope4/meson.build
@@ -0,0 +1,9 @@
+libbaz = shared_library('baz', 'libbaz.c')
+libfoo = shared_library('foo', 'libfoo.c', build_rpath: test_rpath, link_with: libbaz)
+libbar = shared_library('bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo)
+test_depends = [libfoo, libbar, libbaz]
+
+libbaz_native = shared_library('native-baz', 'libbaz.c', native: true)
+libfoo_native = shared_library('native-foo', 'libfoo.c', build_rpath: test_rpath, link_with: libbaz_native, native: true)
+libbar_native = shared_library('native-bar', 'libbar.c', build_rpath: test_rpath, link_with: libfoo_native, native: true)
+test_native_depends = [libfoo_native, libbar_native, libbaz_native]
diff --git a/lib/mlibc/tests/rtdl/scope4/test.c b/lib/mlibc/tests/rtdl/scope4/test.c
new file mode 100644
index 0000000..2365e26
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope4/test.c
@@ -0,0 +1,36 @@
+#include <dlfcn.h>
+#include <stdio.h>
+#include <assert.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBFOO "libnative-foo.so"
+#define LIBBAR "libnative-bar.so"
+#define LIBBAZ "libnative-baz.so"
+#else
+#define LIBFOO "libfoo.so"
+#define LIBBAR "libbar.so"
+#define LIBBAZ "libbaz.so"
+#endif
+
+int main() {
+	// In this test, we have foo -> baz, bar -> foo (where '->' means 'depends on').
+	// We first load foo with RTLD_LOCAL, and then load bar with RTLD_GLOBAL.
+	// This should bring foo and bar into the global scope.
+
+	void *foo = dlopen(LIBFOO, RTLD_LOCAL | RTLD_NOW);
+	assert(foo);
+	assert(dlsym(foo, "foo"));
+	assert(dlsym(foo, "baz"));
+	assert(!dlsym(RTLD_DEFAULT, "foo"));
+	assert(!dlsym(RTLD_DEFAULT, "baz"));
+
+	void *bar = dlopen(LIBBAR, RTLD_GLOBAL | RTLD_NOW);
+	assert(bar);
+	assert(dlsym(bar, "bar"));
+	assert(dlsym(RTLD_DEFAULT, "bar"));
+	assert(dlsym(RTLD_DEFAULT, "foo"));
+	assert(dlsym(RTLD_DEFAULT, "baz"));
+
+	dlclose(foo);
+	dlclose(bar);
+}
diff --git a/lib/mlibc/tests/rtdl/scope5/libfoo.c b/lib/mlibc/tests/rtdl/scope5/libfoo.c
new file mode 100644
index 0000000..85e6cd8
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope5/libfoo.c
@@ -0,0 +1 @@
+void foo() {}
diff --git a/lib/mlibc/tests/rtdl/scope5/meson.build b/lib/mlibc/tests/rtdl/scope5/meson.build
new file mode 100644
index 0000000..22ade5b
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope5/meson.build
@@ -0,0 +1,5 @@
+libfoo = shared_library('foo', 'libfoo.c')
+test_link_with = [libfoo]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c', native: true)
+test_native_link_with = [libfoo_native]
diff --git a/lib/mlibc/tests/rtdl/scope5/test.c b/lib/mlibc/tests/rtdl/scope5/test.c
new file mode 100644
index 0000000..2c11c2e
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/scope5/test.c
@@ -0,0 +1,27 @@
+#include <dlfcn.h>
+#include <stdio.h>
+#include <assert.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBFOO "libnative-foo.so"
+#else
+#define LIBFOO "libfoo.so"
+#endif
+
+// We need to have a relocation against foo for DT_NEEDED.
+void foo();
+void bar() { foo(); }
+
+int main() {
+	// In this test, we have exec -> foo (where '->' means 'depends on').
+	// This means that foo is in the global scope due to DT_NEEDED.
+	// We then dlopen it again with RTLD_LOCAL, which should just return
+	// the already-loaded object, but used to crash in the mlibc linker instead.
+
+	void *foo = dlopen(LIBFOO, RTLD_LOCAL | RTLD_NOW);
+	assert(foo);
+	assert(dlsym(foo, "foo"));
+	assert(dlsym(RTLD_DEFAULT, "foo"));
+
+	dlclose(foo);
+}
diff --git a/lib/mlibc/tests/rtdl/soname/libbar.c b/lib/mlibc/tests/rtdl/soname/libbar.c
new file mode 100644
index 0000000..7f9f475
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/soname/libbar.c
@@ -0,0 +1 @@
+char *name() { return "bar"; }
diff --git a/lib/mlibc/tests/rtdl/soname/libfoo.c b/lib/mlibc/tests/rtdl/soname/libfoo.c
new file mode 100644
index 0000000..abe0999
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/soname/libfoo.c
@@ -0,0 +1 @@
+char *name() { return "foo"; }
diff --git a/lib/mlibc/tests/rtdl/soname/meson.build b/lib/mlibc/tests/rtdl/soname/meson.build
new file mode 100644
index 0000000..1eb97a8
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/soname/meson.build
@@ -0,0 +1,17 @@
+# Create two libraries with the same SONAME.
+bar_soname = '-Wl,-soname=libbar.so'
+
+libfoo = shared_library('foo', 'libfoo.c', link_args: '-Wl,-soname=libbar.so')
+libbar = shared_library('bar', 'libbar.c', link_args: '-Wl,-soname=libbar.so')
+test_depends = [libfoo, libbar]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c',
+	link_args: ['-ldl', '-Wl,-soname=libnative-bar.so'],
+	native: true
+)
+libbar_native = shared_library('native-bar', 'libbar.c',
+	link_args: ['-ldl', '-Wl,-soname=libnative-bar.so'],
+	native: true
+)
+test_native_depends = [libfoo_native, libbar_native]
+
diff --git a/lib/mlibc/tests/rtdl/soname/test.c b/lib/mlibc/tests/rtdl/soname/test.c
new file mode 100644
index 0000000..23e5b7a
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/soname/test.c
@@ -0,0 +1,33 @@
+#include <dlfcn.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+
+#ifdef USE_HOST_LIBC
+#define LIBFOO "libnative-foo.so"
+#define LIBBAR "libnative-bar.so"
+#else
+#define LIBFOO "libfoo.so"
+#define LIBBAR "libbar.so"
+#endif
+
+int main() {
+	void *foo = dlopen(LIBFOO, RTLD_NOW);
+	void *bar = dlopen(LIBBAR, RTLD_NOW);
+	assert(foo);
+	assert(bar);
+
+	// Since these libraries have the same SONAME, they should return the same thing.
+	assert(foo == bar);
+
+	char *(*fooSym)(void) = dlsym(foo, "name");
+	char *(*barSym)(void) = dlsym(bar, "name");
+	assert(fooSym && barSym);
+	assert(fooSym() && barSym());
+	printf("foo: name() = \"%s\"\n", fooSym());
+	printf("bar: name() = \"%s\"\n", barSym());
+	assert(!strcmp(fooSym(), barSym()));
+
+	dlclose(foo);
+	dlclose(bar);
+}
diff --git a/lib/mlibc/tests/rtdl/tls_align/libbar.c b/lib/mlibc/tests/rtdl/tls_align/libbar.c
new file mode 100644
index 0000000..3f8d6a7
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/tls_align/libbar.c
@@ -0,0 +1 @@
+_Thread_local __attribute__((aligned(8))) char bar_thread_local[8] = "Hello!";
diff --git a/lib/mlibc/tests/rtdl/tls_align/libfoo.c b/lib/mlibc/tests/rtdl/tls_align/libfoo.c
new file mode 100644
index 0000000..8d98177
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/tls_align/libfoo.c
@@ -0,0 +1 @@
+_Thread_local __attribute__((aligned(16))) char foo_thread_local[8] = "Hello!";
diff --git a/lib/mlibc/tests/rtdl/tls_align/meson.build b/lib/mlibc/tests/rtdl/tls_align/meson.build
new file mode 100644
index 0000000..61d0fd9
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/tls_align/meson.build
@@ -0,0 +1,7 @@
+libfoo = shared_library('foo', 'libfoo.c')
+libbar = shared_library('bar', 'libbar.c')
+test_link_with = [libfoo, libbar]
+
+libfoo_native = shared_library('native-foo', 'libfoo.c', native: true)
+libbar_native = shared_library('native-bar', 'libbar.c', native: true)
+test_native_link_with = [libfoo_native, libbar_native]
diff --git a/lib/mlibc/tests/rtdl/tls_align/test.c b/lib/mlibc/tests/rtdl/tls_align/test.c
new file mode 100644
index 0000000..4381831
--- /dev/null
+++ b/lib/mlibc/tests/rtdl/tls_align/test.c
@@ -0,0 +1,10 @@
+#include <assert.h>
+#include <stdint.h>
+
+extern _Thread_local char foo_thread_local[];
+extern _Thread_local char bar_thread_local[];
+
+int main() {
+	assert(!((uintptr_t)foo_thread_local & (16 - 1)));
+	assert(!((uintptr_t)bar_thread_local & (8 - 1)));
+}