dynamic-linked TLS support for everything but dlopen'd libs

currently, only i386 is tested. x86_64 and arm should probably work.
the necessary relocation types for mips and microblaze have not been
added because I don't understand how they're supposed to work, and I'm
not even sure if it's defined yet on microblaze. I may be able to
reverse engineer the requirements out of gcc/binutils output.

arch/arm/reloc.h

@@ -6,7 +6,11 @@
 #define IS_COPY(x) ((x)==R_ARM_COPY)
 #define IS_PLT(x) ((x)==R_ARM_JUMP_SLOT)
 
-static inline void do_single_reloc(size_t *reloc_addr, int type, size_t sym_val, size_t sym_size, unsigned char *base_addr, size_t addend)
+static inline void do_single_reloc(
+	struct dso *self, unsigned char *base_addr,
+	size_t *reloc_addr, int type, size_t addend,
+	Sym *sym, size_t sym_size,
+	struct symdef def, size_t sym_val)
 {
 	switch(type) {
 	case R_ARM_ABS32:
@@ -22,5 +26,16 @@ static inline void do_single_reloc(size_t *reloc_addr, int type, size_t sym_val,
 	case R_ARM_COPY:
 		memcpy(reloc_addr, (void *)sym_val, sym_size);
 		break;
+	case R_ARM_TLS_DTPMOD32:
+		*reloc_addr = def.dso ? def.dso->tls_id : self->tls_id;
+		break;
+	case R_ARM_TLS_DTPOFF32:
+		*reloc_addr += def.sym->st_value;
+		break;
+	case R_ARM_TLS_TPOFF32:
+		*reloc_addr += def.sym
+			? def.sym->st_value - def.dso->tls_offset
+			: 0 - self->tls_offset;
+		break;
 	}
 }

arch/i386/reloc.h

@@ -6,7 +6,11 @@
 #define IS_COPY(x) ((x)==R_386_COPY)
 #define IS_PLT(x) ((x)==R_386_JMP_SLOT)
 
-static inline void do_single_reloc(size_t *reloc_addr, int type, size_t sym_val, size_t sym_size, unsigned char *base_addr, size_t addend)
+static inline void do_single_reloc(
+	struct dso *self, unsigned char *base_addr,
+	size_t *reloc_addr, int type, size_t addend,
+	Sym *sym, size_t sym_size,
+	struct symdef def, size_t sym_val)
 {
 	switch(type) {
 	case R_386_32:
@@ -25,5 +29,21 @@ static inline void do_single_reloc(size_t *reloc_addr, int type, size_t sym_val,
 	case R_386_COPY:
 		memcpy(reloc_addr, (void *)sym_val, sym_size);
 		break;
+	case R_386_TLS_DTPMOD32:
+		*reloc_addr = def.dso ? def.dso->tls_id : self->tls_id;
+		break;
+	case R_386_TLS_DTPOFF32:
+		*reloc_addr = def.sym->st_value;
+		break;
+	case R_386_TLS_TPOFF:
+		*reloc_addr += def.sym
+			? def.sym->st_value - def.dso->tls_offset
+			: 0 - self->tls_offset;
+		break;
+	case R_386_TLS_TPOFF32:
+		*reloc_addr += def.sym
+			? def.dso->tls_offset - def.sym->st_value
+			: self->tls_offset;
+		break;
 	}
 }

arch/microblaze/reloc.h

@@ -6,7 +6,11 @@
 #define IS_COPY(x) ((x)==R_MICROBLAZE_COPY)
 #define IS_PLT(x) ((x)==R_MICROBLAZE_JUMP_SLOT)
 
-static inline void do_single_reloc(size_t *reloc_addr, int type, size_t sym_val, size_t sym_size, unsigned char *base_addr, size_t addend)
+static inline void do_single_reloc(
+	struct dso *self, unsigned char *base_addr,
+	size_t *reloc_addr, int type, size_t addend,
+	Sym *sym, size_t sym_size,
+	struct symdef def, size_t sym_val)
 {
 	switch(type) {
 	case R_MICROBLAZE_32:

arch/mips/reloc.h

@@ -6,7 +6,11 @@
 #define IS_COPY(x) ((x)==R_MIPS_COPY)
 #define IS_PLT(x) 1
 
-static inline void do_single_reloc(size_t *reloc_addr, int type, size_t sym_val, size_t sym_size, unsigned char *base_addr, size_t addend)
+static inline void do_single_reloc(
+	struct dso *self, unsigned char *base_addr,
+	size_t *reloc_addr, int type, size_t addend,
+	Sym *sym, size_t sym_size,
+	struct symdef def, size_t sym_val)
 {
 	switch(type) {
 	case R_MIPS_JUMP_SLOT:

arch/x86_64/reloc.h

@@ -7,7 +7,11 @@
 #define IS_COPY(x) ((x)==R_X86_64_COPY)
 #define IS_PLT(x) ((x)==R_X86_64_JUMP_SLOT)
 
-static inline void do_single_reloc(size_t *reloc_addr, int type, size_t sym_val, size_t sym_size, unsigned char *base_addr, size_t addend)
+static inline void do_single_reloc(
+	struct dso *self, unsigned char *base_addr,
+	size_t *reloc_addr, int type, size_t addend,
+	Sym *sym, size_t sym_size,
+	struct symdef def, size_t sym_val)
 {
 	switch(type) {
 	case R_X86_64_GLOB_DAT:
@@ -27,5 +31,16 @@ static inline void do_single_reloc(size_t *reloc_addr, int type, size_t sym_val,
 	case R_X86_64_COPY:
 		memcpy(reloc_addr, (void *)sym_val, sym_size);
 		break;
+	case R_X86_64_TLS_DTPMOD64:
+		*reloc_addr = def.dso ? def.dso->tls_id : self->tls_id;
+		break;
+	case R_X86_64_TLS_DTPOFF64:
+		*reloc_addr = def.sym->st_value + addend;
+		break;
+	case R_X86_64_TLS_TPOFF64:
+		*reloc_addr = (def.sym
+			? def.sym->st_value - def.dso->tls_offset
+			: 0 - self->tls_offset) + addend;
+		break;
 	}
 }

src/ldso/dynlink.c

@@ -68,11 +68,16 @@ struct dso {
 	char constructed;
 	struct dso **deps;
 	void *tls_image;
-	size_t tls_len, tls_size, tls_align, tls_id;
+	size_t tls_len, tls_size, tls_align, tls_id, tls_offset;
 	char *shortname;
 	char buf[];
 };
 
+struct symdef {
+	Sym *sym;
+	struct dso *dso;
+};
+
 #include "reloc.h"
 
 void __init_ssp(size_t *);
@@ -172,13 +177,13 @@ static Sym *gnu_lookup(const char *s, uint32_t h1, struct dso *dso)
 	return 0;
 }
 
-#define OK_TYPES (1<<STT_NOTYPE | 1<<STT_OBJECT | 1<<STT_FUNC | 1<<STT_COMMON)
+#define OK_TYPES (1<<STT_NOTYPE | 1<<STT_OBJECT | 1<<STT_FUNC | 1<<STT_COMMON | 1<<STT_TLS)
 #define OK_BINDS (1<<STB_GLOBAL | 1<<STB_WEAK)
 
-static void *find_sym(struct dso *dso, const char *s, int need_def)
+static struct symdef find_sym(struct dso *dso, const char *s, int need_def)
 {
 	uint32_t h = 0, gh = 0;
-	void *def = 0;
+	struct symdef def = {0};
 	if (dso->ghashtab) {
 		gh = gnu_hash(s);
 		if (gh == 0x1f4039c9 && !strcmp(s, "__stack_chk_fail")) ssp_used = 1;
@@ -199,8 +204,9 @@ static void *find_sym(struct dso *dso, const char *s, int need_def)
 		if (sym && (!need_def || sym->st_shndx) && sym->st_value
 		 && (1<<(sym->st_info&0xf) & OK_TYPES)
 		 && (1<<(sym->st_info>>4) & OK_BINDS)) {
-			if (def && sym->st_info>>4 == STB_WEAK) continue;
+			if (def.sym && sym->st_info>>4 == STB_WEAK) continue;
-			def = dso->base + sym->st_value;
+			def.sym = sym;
+			def.dso = dso;
 			if (sym->st_info>>4 == STB_GLOBAL) break;
 		}
 	}
@@ -214,22 +220,20 @@ static void do_relocs(struct dso *dso, size_t *rel, size_t rel_size, size_t stri
 	char *strings = dso->strings;
 	Sym *sym;
 	const char *name;
-	size_t sym_val, sym_size;
-	size_t *reloc_addr;
 	void *ctx;
 	int type;
 	int sym_index;
+	struct symdef def;
 
 	for (; rel_size; rel+=stride, rel_size-=stride*sizeof(size_t)) {
-		reloc_addr = (void *)(base + rel[0]);
 		type = R_TYPE(rel[1]);
 		sym_index = R_SYM(rel[1]);
 		if (sym_index) {
 			sym = syms + sym_index;
 			name = strings + sym->st_name;
 			ctx = IS_COPY(type) ? head->next : head;
-			sym_val = (size_t)find_sym(ctx, name, IS_PLT(type));
+			def = find_sym(ctx, name, IS_PLT(type));
-			if (!sym_val && sym->st_info>>4 != STB_WEAK) {
+			if (!def.sym && sym->st_info>>4 != STB_WEAK) {
 				snprintf(errbuf, sizeof errbuf,
 					"Error relocating %s: %s: symbol not found",
 					dso->name, name);
@@ -238,11 +242,14 @@ static void do_relocs(struct dso *dso, size_t *rel, size_t rel_size, size_t stri
 				ldso_fail = 1;
 				continue;
 			}
-			sym_size = sym->st_size;
 		} else {
-			sym_val = sym_size = 0;
+			sym = 0;
+			def.sym = 0;
+			def.dso = 0;
 		}
-		do_single_reloc(reloc_addr, type, sym_val, sym_size, base, rel[2]);
+		do_single_reloc(dso, base, (void *)(base + rel[0]), type,
+			stride>2 ? rel[2] : 0, sym, sym?sym->st_size:0, def,
+			def.sym?(size_t)(def.dso->base+def.sym->st_value):0);
 	}
 }
 
@@ -816,9 +823,38 @@ void *__dynlink(int argc, char **argv)
 	if (env_preload) load_preload(env_preload);
 	load_deps(app);
 	make_global(app);
+
+	/* Make an initial pass setting up TLS before performing relocs.
+	 * This provides the TP-based offset of each DSO's TLS for
+	 * use in TP-relative relocations. After relocations, we need
+	 * to copy the TLS images again in case they had relocs. */
+	tls_size += sizeof(struct pthread) + 4*sizeof(size_t);
+	__libc.tls_size = tls_size;
+	__libc.tls_cnt = tls_cnt;
+	if (tls_cnt) {
+		struct dso *p;
+		void *mem = mmap(0, __libc.tls_size, PROT_READ|PROT_WRITE,
+			MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+		if (mem==MAP_FAILED ||
+		    !__install_initial_tls(__copy_tls(mem, tls_cnt))) {
+			dprintf(2, "%s: Error getting %zu bytes thread-local storage: %m\n",
+				argv[0], tls_size);
+			_exit(127);
+		}
+		for (p=head; p; p=p->next) {
+			if (!p->tls_id) continue;
+			p->tls_offset = (char *)__pthread_self()
+				- (char *)__pthread_self()->dtv[p->tls_id];
+		}
+	}
+
 	reloc_all(app->next);
 	reloc_all(app);
 
+	/* The initial DTV is located at the base of the memory
+	 * allocated for TLS. Repeat copying TLS to pick up relocs. */
+	if (tls_cnt) __copy_tls((void *)__pthread_self()->dtv, tls_cnt);
+
 	if (ldso_fail) _exit(127);
 	if (ldd_mode) _exit(0);
 
@@ -840,19 +876,6 @@ void *__dynlink(int argc, char **argv)
 	debug.state = 0;
 	_dl_debug_state();
 
-	tls_size += sizeof(struct pthread) + 4*sizeof(size_t);
-	__libc.tls_size = tls_size;
-	__libc.tls_cnt = tls_cnt;
-	if (tls_cnt) {
-		void *mem = mmap(0, __libc.tls_size, PROT_READ|PROT_WRITE,
-			MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-		if (mem==MAP_FAILED ||
-		    !__install_initial_tls(__copy_tls(mem, tls_cnt))) {
-			dprintf(2, "%s: Error getting %zu bytes thread-local storage: %m\n",
-				argv[0], tls_size);
-			_exit(127);
-		}
-	}
 	if (ssp_used) __init_ssp(auxv);
 
 	do_init_fini(tail);
@@ -933,17 +956,14 @@ static void *do_dlsym(struct dso *p, const char *s, void *ra)
 	size_t i;
 	uint32_t h = 0, gh = 0;
 	Sym *sym;
-	if (p == RTLD_NEXT) {
+	if (p == head || p == RTLD_DEFAULT || p == RTLD_NEXT) {
-		for (p=head; p && (unsigned char *)ra-p->map>p->map_len; p=p->next);
+		if (p == RTLD_NEXT) {
-		if (!p) p=head;
+			for (p=head; p && (unsigned char *)ra-p->map>p->map_len; p=p->next);
-		void *res = find_sym(p->next, s, 0);
+			if (!p) p=head;
-		if (!res) goto failed;
+		}
-		return res;
+		struct symdef def = find_sym(p->next, s, 0);
-	}
+		if (!def.sym) goto failed;
-	if (p == head || p == RTLD_DEFAULT) {
+		return def.dso->base + def.sym->st_value;
-		void *res = find_sym(head, s, 0);
-		if (!res) goto failed;
-		return res;
 	}
 	if (p->ghashtab) {
 		gh = gnu_hash(s);