diff --git a/libexec/rtld-elf/rtld.c b/libexec/rtld-elf/rtld.c
--- a/libexec/rtld-elf/rtld.c
+++ b/libexec/rtld-elf/rtld.c
@@ -167,7 +167,7 @@
 static int symlook_needed(SymLook *, const Needed_Entry *, DoneList *);
 static int symlook_obj1_sysv(SymLook *, const Obj_Entry *);
 static int symlook_obj1_gnu(SymLook *, const Obj_Entry *);
-static void *tls_get_addr_slow(Elf_Addr **, int, size_t, bool) __noinline;
+static void *tls_get_addr_slow(uintptr_t **, int, size_t, bool) __noinline;
 static void trace_loaded_objects(Obj_Entry *, bool);
 static void unlink_object(Obj_Entry *);
 static void unload_object(Obj_Entry *, RtldLockState *lockstate);
@@ -5282,9 +5282,9 @@
  * Common code for MD __tls_get_addr().
  */
 static void *
-tls_get_addr_slow(Elf_Addr **dtvp, int index, size_t offset, bool locked)
+tls_get_addr_slow(uintptr_t **dtvp, int index, size_t offset, bool locked)
 {
-	Elf_Addr *newdtv, *dtv;
+	uintptr_t *newdtv, *dtv;
 	RtldLockState lockstate;
 	int to_copy;
 
@@ -5293,11 +5293,11 @@
 	if (dtv[0] != tls_dtv_generation) {
 		if (!locked)
 			wlock_acquire(rtld_bind_lock, &lockstate);
-		newdtv = xcalloc(tls_max_index + 2, sizeof(Elf_Addr));
+		newdtv = xcalloc(tls_max_index + 2, sizeof(uintptr_t));
 		to_copy = dtv[1];
 		if (to_copy > tls_max_index)
 			to_copy = tls_max_index;
-		memcpy(&newdtv[2], &dtv[2], to_copy * sizeof(Elf_Addr));
+		memcpy(&newdtv[2], &dtv[2], to_copy * sizeof(uintptr_t));
 		newdtv[0] = tls_dtv_generation;
 		newdtv[1] = tls_max_index;
 		free(dtv);
@@ -5312,7 +5312,7 @@
 		if (!locked)
 			wlock_acquire(rtld_bind_lock, &lockstate);
 		if (!dtv[index + 1])
-			dtv[index + 1] = (Elf_Addr)allocate_module_tls(index);
+			dtv[index + 1] = (uintptr_t)allocate_module_tls(index);
 		if (!locked)
 			lock_release(rtld_bind_lock, &lockstate);
 	}
@@ -5368,9 +5368,9 @@
 {
 	Obj_Entry *obj;
 	char *tls_block;
-	Elf_Addr *dtv, **tcb;
-	Elf_Addr addr;
-	Elf_Addr i;
+	uintptr_t *dtv, **tcb;
+	char *addr;
+	uintptr_t i;
 	size_t extra_size, maxalign, post_size, pre_size, tls_block_size;
 	size_t tls_init_align, tls_init_offset;
 
@@ -5391,7 +5391,7 @@
 
 	/* Allocate whole TLS block */
 	tls_block = xmalloc_aligned(tls_block_size, maxalign, 0);
-	tcb = (Elf_Addr **)(tls_block + pre_size + extra_size);
+	tcb = (uintptr_t **)(tls_block + pre_size + extra_size);
 
 	if (oldtcb != NULL) {
 		memcpy(tls_block, get_tls_block_ptr(oldtcb, tcbsize),
@@ -5401,14 +5401,14 @@
 		/* Adjust the DTV. */
 		dtv = tcb[0];
 		for (i = 0; i < dtv[1]; i++) {
-			if (dtv[i + 2] >= (Elf_Addr)oldtcb &&
-			    dtv[i + 2] < (Elf_Addr)oldtcb + tls_static_space) {
-				dtv[i + 2] = dtv[i + 2] - (Elf_Addr)oldtcb +
-				    (Elf_Addr)tcb;
+			if (dtv[i + 2] >= (uintptr_t)oldtcb &&
+			    dtv[i + 2] < (uintptr_t)oldtcb + tls_static_space) {
+				dtv[i + 2] = dtv[i + 2] - (uintptr_t)oldtcb +
+				    (uintptr_t)tcb;
 			}
 		}
 	} else {
-		dtv = xcalloc(tls_max_index + 2, sizeof(Elf_Addr));
+		dtv = xcalloc(tls_max_index + 2, sizeof(uintptr_t));
 		tcb[0] = dtv;
 		dtv[0] = tls_dtv_generation;
 		dtv[1] = tls_max_index;
@@ -5418,21 +5418,21 @@
 			if (obj->tlsoffset == 0)
 				continue;
 			tls_init_offset = obj->tlspoffset & (obj->tlsalign - 1);
-			addr = (Elf_Addr)tcb + obj->tlsoffset;
+			addr = (char *)tcb + obj->tlsoffset;
 			if (tls_init_offset > 0)
-				memset((void *)addr, 0, tls_init_offset);
+				memset(addr, 0, tls_init_offset);
 			if (obj->tlsinitsize > 0) {
-				memcpy((void *)(addr + tls_init_offset),
-				    obj->tlsinit, obj->tlsinitsize);
+				memcpy(addr + tls_init_offset, obj->tlsinit,
+				    obj->tlsinitsize);
 			}
 			if (obj->tlssize > obj->tlsinitsize) {
-				memset((void *)(addr + tls_init_offset +
-					   obj->tlsinitsize),
+				memset(addr + tls_init_offset +
+				    obj->tlsinitsize,
 				    0,
 				    obj->tlssize - obj->tlsinitsize -
 					tls_init_offset);
 			}
-			dtv[obj->tlsindex + 1] = addr;
+			dtv[obj->tlsindex + 1] = (uintptr_t)addr;
 		}
 	}
 
@@ -5442,8 +5442,8 @@
 void
 free_tls(void *tcb, size_t tcbsize, size_t tcbalign __unused)
 {
-	Elf_Addr *dtv;
-	Elf_Addr tlsstart, tlsend;
+	uintptr_t *dtv;
+	uintptr_t tlsstart, tlsend;
 	size_t post_size;
 	size_t dtvsize, i, tls_init_align __unused;
 
@@ -5453,10 +5453,10 @@
 	/* Compute fragments sizes. */
 	post_size = calculate_tls_post_size(tls_init_align);
 
-	tlsstart = (Elf_Addr)tcb + TLS_TCB_SIZE + post_size;
-	tlsend = (Elf_Addr)tcb + tls_static_space;
+	tlsstart = (uintptr_t)tcb + TLS_TCB_SIZE + post_size;
+	tlsend = (uintptr_t)tcb + tls_static_space;
 
-	dtv = *(Elf_Addr **)tcb;
+	dtv = *(uintptr_t **)tcb;
 	dtvsize = dtv[1];
 	for (i = 0; i < dtvsize; i++) {
 		if (dtv[i + 2] != 0 && (dtv[i + 2] < tlsstart ||
@@ -5481,8 +5481,9 @@
 	Obj_Entry *obj;
 	size_t size, ralign;
 	char *tls;
-	Elf_Addr *dtv, *olddtv;
-	Elf_Addr segbase, oldsegbase, addr;
+	uintptr_t *dtv, *olddtv;
+	uintptr_t segbase, oldsegbase;
+	char *addr;
 	size_t i;
 
 	ralign = tcbalign;
@@ -5490,13 +5491,13 @@
 		ralign = tls_static_max_align;
 	size = roundup(tls_static_space, ralign) + roundup(tcbsize, ralign);
 
-	assert(tcbsize >= 2 * sizeof(Elf_Addr));
+	assert(tcbsize >= 2 * sizeof(uintptr_t));
 	tls = xmalloc_aligned(size, ralign, 0 /* XXX */);
-	dtv = xcalloc(tls_max_index + 2, sizeof(Elf_Addr));
+	dtv = xcalloc(tls_max_index + 2, sizeof(uintptr_t));
 
-	segbase = (Elf_Addr)(tls + roundup(tls_static_space, ralign));
-	((Elf_Addr *)segbase)[0] = segbase;
-	((Elf_Addr *)segbase)[1] = (Elf_Addr)dtv;
+	segbase = (uintptr_t)(tls + roundup(tls_static_space, ralign));
+	((uintptr_t *)segbase)[0] = segbase;
+	((uintptr_t *)segbase)[1] = (uintptr_t)dtv;
 
 	dtv[0] = tls_dtv_generation;
 	dtv[1] = tls_max_index;
@@ -5505,7 +5506,7 @@
 		/*
 		 * Copy the static TLS block over whole.
 		 */
-		oldsegbase = (Elf_Addr)oldtls;
+		oldsegbase = (uintptr_t)oldtls;
 		memcpy((void *)(segbase - tls_static_space),
 		    (const void *)(oldsegbase - tls_static_space),
 		    tls_static_space);
@@ -5514,7 +5515,7 @@
 		 * If any dynamic TLS blocks have been created tls_get_addr(),
 		 * move them over.
 		 */
-		olddtv = ((Elf_Addr **)oldsegbase)[1];
+		olddtv = ((uintptr_t **)oldsegbase)[1];
 		for (i = 0; i < olddtv[1]; i++) {
 			if (olddtv[i + 2] < oldsegbase - size ||
 			    olddtv[i + 2] > oldsegbase) {
@@ -5527,20 +5528,19 @@
 		 * We assume that this block was the one we created with
 		 * allocate_initial_tls().
 		 */
-		free_tls(oldtls, 2 * sizeof(Elf_Addr), sizeof(Elf_Addr));
+		free_tls(oldtls, 2 * sizeof(uintptr_t), sizeof(uintptr_t));
 	} else {
 		for (obj = objs; obj != NULL; obj = TAILQ_NEXT(obj, next)) {
 			if (obj->marker || obj->tlsoffset == 0)
 				continue;
-			addr = segbase - obj->tlsoffset;
-			memset((void *)(addr + obj->tlsinitsize), 0,
-			    obj->tlssize - obj->tlsinitsize);
+			addr = (char *)segbase - obj->tlsoffset;
+			memset(addr + obj->tlsinitsize, 0, obj->tlssize -
+			    obj->tlsinitsize);
 			if (obj->tlsinit) {
-				memcpy((void *)addr, obj->tlsinit,
-				    obj->tlsinitsize);
+				memcpy(addr, obj->tlsinit, obj->tlsinitsize);
 				obj->static_tls_copied = true;
 			}
-			dtv[obj->tlsindex + 1] = addr;
+			dtv[obj->tlsindex + 1] = (uintptr_t)addr;
 		}
 	}
 
@@ -5550,10 +5550,10 @@
 void
 free_tls(void *tls, size_t tcbsize __unused, size_t tcbalign)
 {
-	Elf_Addr *dtv;
+	uintptr_t *dtv;
 	size_t size, ralign;
 	int dtvsize, i;
-	Elf_Addr tlsstart, tlsend;
+	uintptr_t tlsstart, tlsend;
 
 	/*
 	 * Figure out the size of the initial TLS block so that we can
@@ -5564,9 +5564,9 @@
 		ralign = tls_static_max_align;
 	size = roundup(tls_static_space, ralign);
 
-	dtv = ((Elf_Addr **)tls)[1];
+	dtv = ((uintptr_t **)tls)[1];
 	dtvsize = dtv[1];
-	tlsend = (Elf_Addr)tls;
+	tlsend = (uintptr_t)tls;
 	tlsstart = tlsend - size;
 	for (i = 0; i < dtvsize; i++) {
 		if (dtv[i + 2] != 0 && (dtv[i + 2] < tlsstart ||