struct tls_module tls;
size_t tls_id;
size_t relro_start, relro_end;
- void **new_dtv;
+ uintptr_t *new_dtv;
unsigned char *new_tls;
volatile int new_dtv_idx, new_tls_idx;
struct td_index *td_index;
new->next = dso->td_index;
dso->td_index = new;
new->args[0] = def.dso->tls_id;
- new->args[1] = tls_val + addend;
+ new->args[1] = tls_val + addend - DTP_OFFSET;
reloc_addr[0] = (size_t)__tlsdesc_dynamic;
reloc_addr[1] = (size_t)new;
} else {
/* Block signals to make accessing new TLS async-signal-safe */
sigset_t set;
__block_all_sigs(&set);
- if (v[0]<=(size_t)self->dtv[0]) {
+ if (v[0] <= self->dtv[0]) {
__restore_sigs(&set);
- return (char *)self->dtv[v[0]]+v[1]+DTP_OFFSET;
+ return (void *)(self->dtv[v[0]] + v[1]);
}
/* This is safe without any locks held because, if the caller
struct dso *p;
for (p=head; p->tls_id != v[0]; p=p->next);
- /* Get new DTV space from new DSO if needed */
- if (v[0] > (size_t)self->dtv[0]) {
- void **newdtv = p->new_dtv +
- (v[0]+1)*a_fetch_add(&p->new_dtv_idx,1);
- memcpy(newdtv, self->dtv,
- ((size_t)self->dtv[0]+1) * sizeof(void *));
- newdtv[0] = (void *)v[0];
- self->dtv = self->dtv_copy = newdtv;
- }
+ /* Get new DTV space from new DSO */
+ uintptr_t *newdtv = p->new_dtv +
+ (v[0]+1)*a_fetch_add(&p->new_dtv_idx,1);
+ memcpy(newdtv, self->dtv, (self->dtv[0]+1) * sizeof(uintptr_t));
+ newdtv[0] = v[0];
+ self->dtv = self->dtv_copy = newdtv;
/* Get new TLS memory from all new DSOs up to the requested one */
unsigned char *mem;
* a_fetch_add(&p->new_tls_idx,1);
mem += ((uintptr_t)p->tls.image - (uintptr_t)mem)
& (p->tls.align-1);
- self->dtv[p->tls_id] = mem;
+ self->dtv[p->tls_id] = (uintptr_t)mem + DTP_OFFSET;
memcpy(mem, p->tls.image, p->tls.len);
if (p->tls_id == v[0]) break;
}
void *p2 = (void *)sp[-1];
if (!p1) {
size_t *auxv, aux[AUX_CNT];
- for (auxv=sp+1+*sp+1; *auxv; auxv++); auxv++;
+ for (auxv=sp+1+*sp+1; *auxv; auxv++);
+ auxv++;
decode_vec(auxv, aux, AUX_CNT);
if (aux[AT_BASE]) ldso.base = (void *)aux[AT_BASE];
else ldso.base = (void *)(aux[AT_PHDR] & -4096);
ldso.relocated = 0;
- /* Call dynamic linker stage-3, __dls3, looking it up
+ /* Call dynamic linker stage-2b, __dls2b, looking it up
* symbolically as a barrier against moving the address
* load across the above relocation processing. */
+ struct symdef dls2b_def = find_sym(&ldso, "__dls2b", 0);
+ if (DL_FDPIC) ((stage3_func)&ldso.funcdescs[dls2b_def.sym-ldso.syms])(sp);
+ else ((stage3_func)laddr(&ldso, dls2b_def.sym->st_value))(sp);
+}
+
+/* Stage 2b sets up a valid thread pointer, which requires relocations
+ * completed in stage 2, and on which stage 3 is permitted to depend.
+ * This is done as a separate stage, with symbolic lookup as a barrier,
+ * so that loads of the thread pointer and &errno can be pure/const and
+ * thereby hoistable. */
+
+_Noreturn void __dls2b(size_t *sp)
+{
+ /* Setup early thread pointer in builtin_tls for ldso/libc itself to
+ * use during dynamic linking. If possible it will also serve as the
+ * thread pointer at runtime. */
+ libc.tls_size = sizeof builtin_tls;
+ libc.tls_align = tls_align;
+ if (__init_tp(__copy_tls((void *)builtin_tls)) < 0) {
+ a_crash();
+ }
+
struct symdef dls3_def = find_sym(&ldso, "__dls3", 0);
if (DL_FDPIC) ((stage3_func)&ldso.funcdescs[dls3_def.sym-ldso.syms])(sp);
else ((stage3_func)laddr(&ldso, dls3_def.sym->st_value))(sp);
libc.secure = ((aux[0]&0x7800)!=0x7800 || aux[AT_UID]!=aux[AT_EUID]
|| aux[AT_GID]!=aux[AT_EGID] || aux[AT_SECURE]);
- /* Setup early thread pointer in builtin_tls for ldso/libc itself to
- * use during dynamic linking. If possible it will also serve as the
- * thread pointer at runtime. */
- libc.tls_size = sizeof builtin_tls;
- libc.tls_align = tls_align;
- if (__init_tp(__copy_tls((void *)builtin_tls)) < 0) {
- a_crash();
- }
-
/* Only trust user/env if kernel says we're not suid/sgid */
if (!libc.secure) {
env_path = getenv("LD_LIBRARY_PATH");
struct symdef def = find_sym(p, s, 0);
if (!def.sym) goto failed;
if ((def.sym->st_info&0xf) == STT_TLS)
- return __tls_get_addr((tls_mod_off_t []){def.dso->tls_id, def.sym->st_value});
+ return __tls_get_addr((tls_mod_off_t []){def.dso->tls_id, def.sym->st_value-DTP_OFFSET});
if (DL_FDPIC && (def.sym->st_info&0xf) == STT_FUNC)
return def.dso->funcdescs + (def.sym - def.dso->syms);
return laddr(def.dso, def.sym->st_value);
sym = sysv_lookup(s, h, p);
}
if (sym && (sym->st_info&0xf) == STT_TLS)
- return __tls_get_addr((tls_mod_off_t []){p->tls_id, sym->st_value});
+ return __tls_get_addr((tls_mod_off_t []){p->tls_id, sym->st_value-DTP_OFFSET});
if (DL_FDPIC && sym && sym->st_shndx && (sym->st_info&0xf) == STT_FUNC)
return p->funcdescs + (sym - p->syms);
if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES))
sym = sysv_lookup(s, h, p->deps[i]);
}
if (sym && (sym->st_info&0xf) == STT_TLS)
- return __tls_get_addr((tls_mod_off_t []){p->deps[i]->tls_id, sym->st_value});
+ return __tls_get_addr((tls_mod_off_t []){p->deps[i]->tls_id, sym->st_value-DTP_OFFSET});
if (DL_FDPIC && sym && sym->st_shndx && (sym->st_info&0xf) == STT_FUNC)
return p->deps[i]->funcdescs + (sym - p->deps[i]->syms);
if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES))