Update.

2002-02-12  Ulrich Drepper  <drepper@redhat.com>

	* sysdeps/generic/dl-tls.c (TLS_DTV_UNALLOCATED): Renamed from
	TLS_DTV_UNALLOCATE.
	(oom): New function.
	(_dl_next_tls_modid): Rewrite to handle dl_tls_dtv_slotinfo_list.
	(_dl_determine_tlsoffset): Likewise.
	(_dl_allocate_tls): Likewise.
	(__TLS_GET_ADDR): Define if not already defined.
	(_dl_tls_symaddr): New function.
	(allocate_and_init): New function.
	(__tls_get_addr): Actually implement handling of generation counter
	and deferred allocation.
	* sysdeps/generic/ldsodefs.h (_rtld_global): Remove _dl_initimage_list,
	add _dl_tls_dtv_slotinfo_list, _dl_tls_static_nelem, and
	_dl_tls_generation.
	Define TLS_SLOTINFO_SURPLUS and DTV_SURPLUS.
	Declare _dl_tls_symaddr.
	* sysdeps/i386/dl-tls.h: Disable __tls_get_addr handling unless
	SHARED.
	* include/link.h (struct link_map):  Remove l_tls_nextimage and
	l_tls_previmage.
	* elf/dl-sym.c (_dl_sym): After successful lookup call _dl_tls_symaddr
	instead of DL_SYMBOL_ADDRESS for STT_TLS symbols.
	(_dl_vsym): Likewise.
	* elf/rtld.c (_dl_start_final): Adjust initdtv initialization for new
	layout.
	(dl_main): Allow PT_TLS be present for empty segment.  Remove
	nextimage list handling.  Instead add all modules using TLS to
	dl_tls_dtv_slotinfo_list.
	* elf/dl-open.c (dl_open_worker): After successfully loading all
	objects add those with TLS to the dl_tls_dtv_slotinfo_list list.
	* elf/dl-load.c (_dl_map_object_from_fd): If PT_TLS entry is for an
	empty segment don't do anything.  Remove handling of initimage list.
	* elf/Versions [ld] (GLIBC_2.0): Add __libc_memalign.
	(GLIBC_PRIVATE): Add _dl_tls_symaddr.
	* elf/dl-minimal.c: Define __libc_memalign.
	* elf/dl-support.c: Remove _dl_initimage_list.  Add
	_dl_tls_dtv_slotinfo_list, _dl_tls_static_nelem, and
	_dl_tls_generation.
	* include/stdlib.h: Declare __libc_memalign.

	* elf/Makefile: Add rules to build and run tst-tls4 and tst-tls5.
	* elf/tst-tls4.c: New file.
	* elf/tst-tls5.c: New file.
	* elf/tst-tlsmod2.c: New file.

	* elf/tls-macros.h: asms using ___tls_get_addr destroy %ecx and %edx.

	* elf/tst-tlsmod1.c: Don't define variables unles USE_TLS.

	* elf/tst-tls1.c: Use test-skeleton.c.
	* elf/tst-tls2.c: Likewise.
	* elf/tst-tls3.c: Likewise.

	* elf/dl-conflict.c (RESOLVE_MAP): Return NULL not 0.

	* sysdeps/mips/machine-gmon.h: Update MCOUNT for current GCC behavior.

ChangeLog

@@ -1,7 +1,63 @@
+2002-02-12  Ulrich Drepper  <drepper@redhat.com>
+
+	* sysdeps/generic/dl-tls.c (TLS_DTV_UNALLOCATED): Renamed from
+	TLS_DTV_UNALLOCATE.
+	(oom): New function.
+	(_dl_next_tls_modid): Rewrite to handle dl_tls_dtv_slotinfo_list.
+	(_dl_determine_tlsoffset): Likewise.
+	(_dl_allocate_tls): Likewise.
+	(__TLS_GET_ADDR): Define if not already defined.
+	(_dl_tls_symaddr): New function.
+	(allocate_and_init): New function.
+	(__tls_get_addr): Actually implement handling of generation counter
+	and deferred allocation.
+	* sysdeps/generic/ldsodefs.h (_rtld_global): Remove _dl_initimage_list,
+	add _dl_tls_dtv_slotinfo_list, _dl_tls_static_nelem, and
+	_dl_tls_generation.
+	Define TLS_SLOTINFO_SURPLUS and DTV_SURPLUS.
+	Declare _dl_tls_symaddr.
+	* sysdeps/i386/dl-tls.h: Disable __tls_get_addr handling unless
+	SHARED.
+	* include/link.h (struct link_map):  Remove l_tls_nextimage and
+	l_tls_previmage.
+	* elf/dl-sym.c (_dl_sym): After successful lookup call _dl_tls_symaddr
+	instead of DL_SYMBOL_ADDRESS for STT_TLS symbols.
+	(_dl_vsym): Likewise.
+	* elf/rtld.c (_dl_start_final): Adjust initdtv initialization for new
+	layout.
+	(dl_main): Allow PT_TLS be present for empty segment.  Remove
+	nextimage list handling.  Instead add all modules using TLS to
+	dl_tls_dtv_slotinfo_list.
+	* elf/dl-open.c (dl_open_worker): After successfully loading all
+	objects add those with TLS to the dl_tls_dtv_slotinfo_list list.
+	* elf/dl-load.c (_dl_map_object_from_fd): If PT_TLS entry is for an
+	empty segment don't do anything.  Remove handling of initimage list.
+	* elf/Versions [ld] (GLIBC_2.0): Add __libc_memalign.
+	(GLIBC_PRIVATE): Add _dl_tls_symaddr.
+	* elf/dl-minimal.c: Define __libc_memalign.
+	* elf/dl-support.c: Remove _dl_initimage_list.  Add
+	_dl_tls_dtv_slotinfo_list, _dl_tls_static_nelem, and
+	_dl_tls_generation.
+	* include/stdlib.h: Declare __libc_memalign.
+
+	* elf/Makefile: Add rules to build and run tst-tls4 and tst-tls5.
+	* elf/tst-tls4.c: New file.
+	* elf/tst-tls5.c: New file.
+	* elf/tst-tlsmod2.c: New file.
+
+	* elf/tls-macros.h: asms using ___tls_get_addr destroy %ecx and %edx.
+
+	* elf/tst-tlsmod1.c: Don't define variables unles USE_TLS.
+
+	* elf/tst-tls1.c: Use test-skeleton.c.
+	* elf/tst-tls2.c: Likewise.
+	* elf/tst-tls3.c: Likewise.
+
+	* elf/dl-conflict.c (RESOLVE_MAP): Return NULL not 0.
+
 2002-02-08  Daniel Jacobowitz  <drow@mvista.com>
 
-	* sysdeps/mips/machine-gmon.h: Update MCOUNT for current GCC
+	* sysdeps/mips/machine-gmon.h: Update MCOUNT for current GCC behavior.
-	behavior.
 
 2002-02-10  Ulrich Drepper  <drepper@redhat.com>
 

elf/Makefile

@@ -119,7 +119,7 @@ tests = loadtest restest1 preloadtest loadfail multiload origtest resolvfail \
 	$(tests-nodlopen-$(have-z-nodlopen)) neededtest neededtest2 \
 	neededtest3 neededtest4 unload2 lateglobal initfirst global \
 	restest2 next dblload dblunload reldep5 reldep6 tst-tls1 tst-tls2 \
-	tst-tls3
+	tst-tls3 tst-tls4 tst-tls5
 test-srcs = tst-pathopt
 tests-vis-yes = vismain
 tests-nodelete-yes = nodelete
@@ -137,7 +137,7 @@ modules-names = testobj1 testobj2 testobj3 testobj4 testobj5 testobj6 \
 		unload2mod unload2dep ltglobmod1 ltglobmod2 pathoptobj \
 		dblloadmod1 dblloadmod2 dblloadmod3 reldepmod5 reldepmod6 \
 	        reldep6mod0 reldep6mod1 reldep6mod2 reldep6mod3 reldep6mod4 \
-		tst-tlsmod1
+		tst-tlsmod1 tst-tlsmod2
 modules-vis-yes = vismod1 vismod2 vismod3
 modules-nodelete-yes = nodelmod1 nodelmod2 nodelmod3 nodelmod4
 modules-nodlopen-yes = nodlopenmod nodlopenmod2
@@ -442,3 +442,9 @@ $(objpfx)reldep6: $(libdl)
 $(objpfx)reldep6.out: $(objpfx)reldep6mod3.so $(objpfx)reldep6mod4.so
 
 $(objpfx)tst-tls3: $(objpfx)tst-tlsmod1.so
+
+$(objpfx)tst-tls4: $(libdl)
+$(objpfx)tst-tls4.out: $(objpfx)tst-tlsmod2.so
+
+$(objpfx)tst-tls5: $(libdl)
+$(objpfx)tst-tls5.out: $(objpfx)tst-tlsmod2.so

elf/Versions

@@ -27,7 +27,7 @@ libc {
 ld {
   GLIBC_2.0 {
     # Function from libc.so which must be shared with libc.
-    calloc; free; malloc; realloc;
+    calloc; free; malloc; realloc; __libc_memalign;
 
     _r_debug;
   }
@@ -49,6 +49,6 @@ ld {
     _dl_map_object; _dl_map_object_deps; _dl_out_of_memory;
     _dl_relocate_object; _dl_signal_error; _dl_start_profile; _dl_starting_up;
     _dl_unload_cache;
-    _rtld_global;
+    _rtld_global; _dl_tls_symaddr;
   }
 }

elf/dl-load.c

@@ -941,6 +941,8 @@ _dl_map_object_from_fd (const char *name, int fd, struct filebuf *fbp,
 
 #ifdef USE_TLS
 	case PT_TLS:
+	  if (ph->p_memsz > 0)
+	    {
 	      l->l_tls_blocksize = ph->p_memsz;
 	      l->l_tls_align = ph->p_align;
 	      l->l_tls_initimage_size = ph->p_filesz;
@@ -948,23 +950,9 @@ _dl_map_object_from_fd (const char *name, int fd, struct filebuf *fbp,
 		 offset.  We will adjust it later.  */
 	      l->l_tls_initimage = (void *) ph->p_offset;
 
-	/* This is the first element of the initialization image list.
-	   It is created as a circular list so that we can easily
-	   append to it.  */
-	  if (GL(dl_initimage_list) == NULL)
-	    GL(dl_initimage_list) = l->l_tls_nextimage = l->l_tls_previmage
-	      = l;
-	  else
-	    {
-	      l->l_tls_nextimage = GL(dl_initimage_list)->l_tls_nextimage;
-	      l->l_tls_nextimage->l_tls_previmage = l;
-	      l->l_tls_previmage = GL(dl_initimage_list);
-	      l->l_tls_previmage->l_tls_nextimage = l;
-	      GL(dl_initimage_list) = l;
-	    }
-
 	      /* Assign the next available module ID.  */
 	      l->l_tls_modid = _dl_next_tls_modid ();
+	    }
 	  break;
 #endif
 	}

elf/dl-minimal.c

@@ -21,8 +21,9 @@
 #include <limits.h>
 #include <string.h>
 #include <unistd.h>
-#include <sys/types.h>
 #include <sys/mman.h>
+#include <sys/param.h>
+#include <sys/types.h>
 #include <ldsodefs.h>
 #include <stdio-common/_itoa.h>
 
@@ -120,6 +121,15 @@ realloc (void *ptr, size_t n)
   assert (new == ptr);
   return new;
 }
+
+/* Return alligned memory block.  */
+void * weak_function
+__libc_memalign (size_t align, size_t n)
+{
+  void *newp = malloc (n + align - 1);
+
+  return (void *) roundup ((uintptr_t) newp, align);
+}
 
 /* Avoid signal frobnication in setjmp/longjmp.  Keeps things smaller.  */
 

elf/dl-open.c

@@ -31,6 +31,7 @@
 #include <bp-sym.h>
 
 #include <dl-dst.h>
+#include <dl-tls.h>
 
 
 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
@@ -353,6 +354,73 @@ dl_open_worker (void *a)
 	imap->l_scope[cnt++] = &new->l_searchlist;
 	imap->l_scope[cnt] = NULL;
       }
+#if USE_TLS
+    else if (new->l_searchlist.r_list[i]->l_opencount == 1
+	     /* Only if the module defines thread local data.  */
+	     && __builtin_expect (new->l_searchlist.r_list[i]->l_tls_blocksize
+				  > 0, 0))
+      {
+	/* Now that we know the object is loaded successfully add
+	   modules containing TLS data to the dtv info table.  We
+	   might have to increase its size.  */
+	struct dtv_slotinfo_list *listp;
+	struct dtv_slotinfo_list *prevp;
+	size_t idx = new->l_searchlist.r_list[i]->l_tls_modid;
+
+	assert (new->l_searchlist.r_list[i]->l_type == lt_loaded);
+
+	/* Find the place in the stv slotinfo list.  */
+	listp = GL(dl_tls_dtv_slotinfo_list);
+	prevp = NULL;		/* Needed to shut up gcc.  */
+	do
+	  {
+	    /* Does it fit in the array of this list element?  */
+	    if (idx <= listp->len)
+	      break;
+	    prevp = listp;
+	  }
+	while ((listp = listp->next) != NULL);
+
+	if (listp == NULL)
+	  {
+	    /* When we come here it means we have to add a new element
+	       to the slotinfo list.  And the new module must be in
+	       the first slot.  */
+	    assert (idx == 0);
+
+	    listp = prevp->next = (struct dtv_slotinfo_list *)
+	      malloc (sizeof (struct dtv_slotinfo_list)
+		      + TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo));
+	    if (listp == NULL)
+	      {
+		/* We ran out of memory.  We will simply fail this
+		   call but don't undo anything we did so far.  The
+		   application will crash or be terminated anyway very
+		   soon.  */
+
+		/* We have to do this since some entries in the dtv
+		   slotinfo array might already point to this
+		   generation.  */
+		++GL(dl_tls_generation);
+
+		_dl_signal_error (ENOMEM, "dlopen", NULL,
+				  N_("cannot create TLS data structures"));
+	      }
+
+	    listp->len = TLS_SLOTINFO_SURPLUS;
+	    listp->next = NULL;
+	    memset (listp->slotinfo, '\0',
+		    TLS_SLOTINFO_SURPLUS * sizeof (struct dtv_slotinfo));
+	  }
+
+	/* Add the information into the slotinfo data structure.  */
+	listp->slotinfo[idx].map = new->l_searchlist.r_list[i];
+	listp->slotinfo[idx].gen = GL(dl_tls_generation) + 1;
+      }
+
+  /* Bump the generation number.  */
+  ++GL(dl_tls_generation);
+#endif
 
   /* Run the initializer functions of new objects.  */
   _dl_init (new, __libc_argc, __libc_argv, __environ);
@@ -424,11 +492,19 @@ _dl_open (const char *file, int mode, const void *caller)
 	{
 	  unsigned int i;
 
-	  /* Increment open counters for all objects since this has
+	  /* Increment open counters for all objects since this
-	     not happened yet.  */
+	     sometimes has not happened yet.  */
+	  if (args.map->l_searchlist.r_list[0]->l_opencount == 0)
 	    for (i = 0; i < args.map->l_searchlist.r_nlist; ++i)
 	      ++args.map->l_searchlist.r_list[i]->l_opencount;
 
+	  /* Maybe some of the modules which were loaded uses TLS.
+	     Since it will be removed in the folowing _dl_close call
+	     we have to mark the dtv array as having gaps to fill
+	     the holes.  This is a pessimistic assumption which won't
+	     hurt if not true.  */
+	  GL(dl_tls_dtv_gaps) = true;
+
 	  _dl_close (args.map);
 	}
 

elf/dl-support.c

@@ -138,20 +138,22 @@ int _dl_correct_cache_id = _DL_CACHE_DEFAULT_ID;
 __libc_lock_define_initialized_recursive (, _dl_load_lock)
 
 #ifdef USE_TLS
-/* Beginning of the list of link maps for objects which contain
-   thread-local storage sections.  This will be traversed to
-   initialize new TLS blocks.  */
-struct link_map *_dl_initimage_list;
 
 /* Highest dtv index currently needed.  */
 size_t _dl_tls_max_dtv_idx;
 /* Flag signalling whether there are gaps in the module ID allocation.  */
 bool _dl_tls_dtv_gaps;
-
+/* Information about the dtv slots.  */
+struct dtv_slotinfo_list *_dl_tls_dtv_slotinfo_list;
+/* Number of modules in the static TLS block.  */
+size_t _dl_tls_static_nelem;
 /* Size of the static TLS block.  */
 size_t _dl_tls_static_size;
 /* Alignment requirement of the static TLS block.  */
 size_t _dl_tls_static_align;
+
+/* Generation counter for the dtv.  */
+size_t _dl_tls_generation;
 #endif
 
 

elf/dl-sym.c

@@ -83,7 +83,16 @@ RTLD_NEXT used in code not dynamically loaded"));
     }
 
   if (ref != NULL)
+    {
+#if defined USE_TLS && defined SHARED
+      if (ELFW(ST_TYPE) (ref->st_info) == STT_TLS)
+	/* The found symbol is a thread-local storage variable.
+	   Return the address for to the current thread.  */
+	return _dl_tls_symaddr (result, ref);
+#endif
+
       return DL_SYMBOL_ADDRESS (result, ref);
+    }
 
   return NULL;
 }
@@ -152,7 +161,16 @@ RTLD_NEXT used in code not dynamically loaded"));
     }
 
   if (ref != NULL)
+    {
+#if defined USE_TLS && defined SHARED
+      if (ELFW(ST_TYPE) (ref->st_info) == STT_TLS)
+	/* The found symbol is a thread-local storage variable.
+	   Return the address for to the current thread.  */
+	return _dl_tls_symaddr (result, ref);
+#endif
+
       return DL_SYMBOL_ADDRESS (result, ref);
+    }
 
   return NULL;
 }

elf/rtld.c

@@ -223,7 +223,7 @@ _dl_start_final (void *arg, struct link_map *bootstrap_map_p,
   ElfW(Ehdr) *ehdr;
   ElfW(Phdr) *phdr;
   size_t cnt;
-  dtv_t initdtv[2];
+  dtv_t initdtv[3];
 #endif
 
   if (HP_TIMING_AVAIL)
@@ -291,16 +291,18 @@ _dl_start_final (void *arg, struct link_map *bootstrap_map_p,
 	tlsblock = (void *) (((uintptr_t) tlsblock + max_align - 1)
 			     & ~(max_align - 1));
 
-	/* Initialize the dtv.  */
+	/* Initialize the dtv.  [0] is the length, [1] the generation
+	   counter.  */
 	initdtv[0].counter = 1;
+	initdtv[1].counter = 0;
 
 	/* Initialize the TLS block.  */
 # if TLS_TCB_AT_TP
-	initdtv[1].pointer = tlsblock;
+	initdtv[2].pointer = tlsblock;
 # elif TLS_DTV_AT_TP
 	GL(dl_rtld_map).l_tls_offset = roundup (TLS_INIT_TCB_SIZE,
 						GL(dl_rtld_map).l_tls_align);
-	initdtv[1].pointer = (char *) tlsblock + GL(dl_rtld_map).l_tls_offset);
+	initdtv[2].pointer = (char *) tlsblock + GL(dl_rtld_map).l_tls_offset);
 # else
 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 # endif
@@ -723,6 +725,8 @@ of this helper program; chances are you did not intend to run this program.\n\
 	break;
 #ifdef USE_TLS
       case PT_TLS:
+	if (ph->p_memsz > 0)
+	  {
 	    /* Note that in the case the dynamic linker we duplicate work
 	       here since we read the PT_TLS entry already in
 	       _dl_start_final.  But the result is repeatable so do not
@@ -731,14 +735,10 @@ of this helper program; chances are you did not intend to run this program.\n\
 	    GL(dl_loaded)->l_tls_align = ph->p_align;
 	    GL(dl_loaded)->l_tls_initimage_size = ph->p_filesz;
 	    GL(dl_loaded)->l_tls_initimage = (void *) ph->p_vaddr;
-	/* This is the first element of the initialization image list.
-	   We create the list as circular since we have to append at
-	   the end.  */
-	GL(dl_initimage_list) = GL(dl_loaded)->l_tls_nextimage
-	  = GL(dl_loaded)->l_tls_previmage = GL(dl_loaded);
 
 	    /* This image gets the ID one.  */
 	    GL(dl_tls_max_dtv_idx) = GL(dl_loaded)->l_tls_modid = 1;
+	  }
 	break;
 #endif
       }
@@ -1188,31 +1188,52 @@ of this helper program; chances are you did not intend to run this program.\n\
      use the static model.  First add the dynamic linker to the list
      if it also uses TLS.  */
   if (GL(dl_rtld_map).l_tls_blocksize != 0)
-    {
-      /* At to the list.  */
-      if (GL(dl_initimage_list) == NULL)
-	GL(dl_initimage_list) = GL(dl_rtld_map).l_tls_nextimage
-	  = GL(dl_rtld_map).l_tls_previmage = &GL(dl_rtld_map);
-	  else
-	    {
-	      GL(dl_rtld_map).l_tls_nextimage
-		= GL(dl_initimage_list)->l_tls_nextimage;
-	      GL(dl_rtld_map).l_tls_nextimage->l_tls_previmage
-		= &GL(dl_rtld_map);
-	      GL(dl_rtld_map).l_tls_previmage = GL(dl_initimage_list);
-	      GL(dl_rtld_map).l_tls_previmage->l_tls_nextimage
-		= &GL(dl_rtld_map);
-	      GL(dl_initimage_list) = &GL(dl_rtld_map);
-	    }
-
     /* Assign a module ID.  */
     GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();
-    }
+
+# ifndef SHARED
+  /* If dynamic loading of modules with TLS is impossible we do not
+     have to initialize any of the TLS functionality unless any of the
+     initial modules uses TLS.  */
+  if (GL(dl_tls_max_dtv_idx) > 0)
+# endif
+    {
+      struct link_map *l;
+      size_t nelem;
+      struct dtv_slotinfo *slotinfo;
+
+      /* Number of elements in the static TLS block.  */
+      GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx);
+
+      /* Allocate the array which contains the information about the
+	 dtv slots.  We allocate a few entries more than needed to
+	 avoid the need for reallocation.  */
+      nelem = GL(dl_tls_max_dtv_idx) + 1 + TLS_SLOTINFO_SURPLUS;
+
+      /* Allocate.  */
+      GL(dl_tls_dtv_slotinfo_list) = (struct dtv_slotinfo_list *)
+	malloc (sizeof (struct dtv_slotinfo_list)
+		+ nelem * sizeof (struct dtv_slotinfo));
+      /* No need to check the return value.  If memory allocation failed
+	 the program would have been terminated.  */
+
+      slotinfo = memset (GL(dl_tls_dtv_slotinfo_list)->slotinfo, '\0',
+			 nelem * sizeof (struct dtv_slotinfo));
+      GL(dl_tls_dtv_slotinfo_list)->len = nelem;
+      GL(dl_tls_dtv_slotinfo_list)->next = NULL;
+
+      /* Fill in the information from the loaded modules.  */
+      for (l = GL(dl_loaded), i = 0; l != NULL; l = l->l_next)
+	if (l->l_tls_blocksize != 0)
+	  /* This is a module with TLS data.  Store the map reference.
+	     The generation counter is zero.  */
+	  slotinfo[++i].map = l;
+      assert (i == GL(dl_tls_max_dtv_idx));
 
       /* Computer the TLS offsets for the various blocks.  We call this
 	 function even if none of the modules available at startup time
 	 uses TLS to initialize some variables.  */
-    _dl_determine_tlsoffset (GL(dl_initimage_list));
+      _dl_determine_tlsoffset ();
 
       /* Construct the static TLS block and the dtv for the initial
 	 thread.  For some platforms this will include allocating memory
@@ -1221,10 +1242,12 @@ of this helper program; chances are you did not intend to run this program.\n\
 	 array can be changed if dynamic loading requires it.  */
       tcbp = _dl_allocate_tls ();
       if (tcbp == NULL)
-    _dl_fatal_printf ("cannot allocate TLS data structures for inital thread");
+	_dl_fatal_printf ("\
+cannot allocate TLS data structures for inital thread");
 
       /* And finally install it for the main thread.  */
       TLS_INIT_TP (tcbp);
+    }
 #endif
 
   if (GL(dl_loaded)->l_info [ADDRIDX (DT_GNU_LIBLIST)]

elf/tls-macros.h

@@ -49,15 +49,15 @@
 
 # ifdef PIC
 #  define TLS_LD(x) \
-  ({ int *__l;								      \
+  ({ int *__l, __c, __d;						      \
      asm ("leal " #x "@tlsldm(%%ebx),%%eax\n\t"				      \
 	  "call ___tls_get_addr@plt\n\t"				      \
 	  "leal " #x "@dtpoff(%%eax), %%eax"				      \
-	  : "=a" (__l));						      \
+	  : "=a" (__l), "=&c" (__c), "=&d" (__d));			      \
      __l; })
 # else
 #  define TLS_LD(x) \
-  ({ int *__l, __b;							      \
+  ({ int *__l, __b, __c, __d;						      \
      asm ("call 1f\n\t"							      \
 	  ".subsection 1\n"						      \
 	  "1:\tmovl (%%esp), %%ebx\n\t"					      \
@@ -67,21 +67,21 @@
 	  "leal " #x "@tlsldm(%%ebx),%%eax\n\t"				      \
 	  "call ___tls_get_addr@plt\n\t"				      \
 	  "leal " #x "@dtpoff(%%eax), %%eax"				      \
-	  : "=a" (__l), "=&b" (__b));					      \
+	  : "=a" (__l), "=&b" (__b), "=&c" (__c), "=&d" (__d));		      \
      __l; })
 # endif
 
 # ifdef PIC
 #  define TLS_GD(x) \
-  ({ int *__l;								      \
+  ({ int *__l, __c, __d;						      \
      asm ("leal " #x "@tlsgd(%%ebx),%%eax\n\t"				      \
 	  "call ___tls_get_addr@plt\n\t"				      \
 	  "nop"								      \
-	  : "=a" (__l));						      \
+	  : "=a" (__l), "=&c" (__c), "=&d" (__d));			      \
      __l; })
 # else
 #  define TLS_GD(x) \
-  ({ int *__l, __b;							      \
+  ({ int *__l, __b, __c, __d;						      \
      asm ("call 1f\n\t"							      \
 	  ".subsection 1\n"						      \
 	  "1:\tmovl (%%esp), %%ebx\n\t"					      \
@@ -91,7 +91,7 @@
 	  "leal " #x "@tlsgd(%%ebx),%%eax\n\t"				      \
 	  "call ___tls_get_addr@plt\n\t"				      \
 	  "nop"								      \
-	  : "=a" (__l), "=&b" (__b));					      \
+	  : "=a" (__l), "=&b" (__b), "=&c" (__c), "=&d" (__d));		      \
      __l; })
 # endif
 

elf/tst-tls1.c

@@ -5,13 +5,16 @@
 #include "tls-macros.h"
 
 
+#ifdef USE_TLS
 /* Two common 'int' variables in TLS.  */
 COMMON_INT_DEF(foo);
 COMMON_INT_DEF(bar);
+#endif
 
 
-int
+#define TEST_FUNCTION do_test ()
-main (void)
+static int
+do_test (void)
 {
 #ifdef USE_TLS
   int result = 0;
@@ -82,3 +85,6 @@ main (void)
   return 0;
 #endif
 }
+
+
+#include "../test-skeleton.c"

elf/tst-tls2.c

@@ -5,13 +5,16 @@
 #include "tls-macros.h"
 
 
+#ifdef USE_TLS
 /* Two 'int' variables in TLS.  */
 VAR_INT_DEF(foo);
 VAR_INT_DEF(bar);
+#endif
 
 
-int
+#define TEST_FUNCTION do_test ()
-main (void)
+static int
+do_test (void)
 {
 #ifdef USE_TLS
   int result = 0;
@@ -82,3 +85,6 @@ main (void)
   return 0;
 #endif
 }
+
+
+#include "../test-skeleton.c"

elf/tst-tls3.c

@@ -5,17 +5,20 @@
 #include "tls-macros.h"
 
 
+#ifdef USE_TLS
 /* One define int variable, two externs.  */
 COMMON_INT_DECL(foo);
 VAR_INT_DECL(bar);
 VAR_INT_DEF(baz);
+#endif
 
 
 extern int in_dso (void);
 
 
-int
+#define TEST_FUNCTION do_test ()
-main (void)
+static int
+do_test (void)
 {
 #ifdef USE_TLS
   int result = 0;
@@ -67,3 +70,6 @@ main (void)
   return 0;
 #endif
 }
+
+
+#include "../test-skeleton.c"

elf/tst-tls4.c

@@ -0,0 +1,56 @@
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <tls.h>
+
+
+#define TEST_FUNCTION do_test ()
+static int
+do_test (void)
+{
+#ifdef USE_TLS
+  static const char modname[] = "tst-tlsmod2.so";
+  int result = 0;
+  int *foop;
+  int (*fp) (int, int *);
+  void *h;
+
+  h = dlopen (modname, RTLD_LAZY);
+  if (h == NULL)
+    {
+      printf ("cannot open '%s': %s\n", modname, dlerror ());
+      exit (1);
+    }
+
+  fp = dlsym (h, "in_dso");
+  if (fp == NULL)
+    {
+      printf ("cannot get symbol 'in_dso': %s\n", dlerror ());
+      exit (1);
+    }
+
+  result |= fp (0, NULL);
+
+  foop = dlsym (h, "foo");
+  if (foop == NULL)
+    {
+      printf ("cannot get symbol 'foo' the second time: %s\n", dlerror ());
+      exit (1);
+    }
+  if (*foop != 16)
+    {
+      puts ("foo != 16");
+      result = 1;
+    }
+
+  dlclose (h);
+
+  return result;
+#else
+  return 0;
+#endif
+}
+
+
+#include "../test-skeleton.c"

elf/tst-tls5.c

@@ -0,0 +1,72 @@
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <tls.h>
+
+
+#define TEST_FUNCTION do_test ()
+static int
+do_test (void)
+{
+#ifdef USE_TLS
+  static const char modname[] = "tst-tlsmod2.so";
+  int result = 0;
+  int *foop;
+  int *foop2;
+  int (*fp) (int, int *);
+  void *h;
+
+  h = dlopen (modname, RTLD_LAZY);
+  if (h == NULL)
+    {
+      printf ("cannot open '%s': %s\n", modname, dlerror ());
+      exit (1);
+    }
+
+  foop = dlsym (h, "foo");
+  if (foop == NULL)
+    {
+      printf ("cannot get symbol 'foo': %s\n", dlerror ());
+      exit (1);
+    }
+
+  *foop = 42;
+
+  fp = dlsym (h, "in_dso");
+  if (fp == NULL)
+    {
+      printf ("cannot get symbol 'in_dso': %s\n", dlerror ());
+      exit (1);
+    }
+
+  result |= fp (42, foop);
+
+  foop2 = dlsym (h, "foo");
+  if (foop2 == NULL)
+    {
+      printf ("cannot get symbol 'foo' the second time: %s\n", dlerror ());
+      exit (1);
+    }
+
+  if (foop != foop2)
+    {
+      puts ("address of 'foo' different the second time");
+      result = 1;
+    }
+  else if (*foop != 16)
+    {
+      puts ("foo != 16");
+      result = 1;
+    }
+
+  dlclose (h);
+
+  return result;
+#else
+  return 0;
+#endif
+}
+
+
+#include "../test-skeleton.c"

elf/tst-tlsmod1.c

@@ -4,10 +4,12 @@
 #include "tls-macros.h"
 
 
+#ifdef USE_TLS
 /* One define int variable, two externs.  */
 COMMON_INT_DEF(foo);
 VAR_INT_DEF(bar);
 VAR_INT_DECL(baz);
+#endif
 
 
 int

elf/tst-tlsmod2.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+
+#include <tls.h>
+#include "tls-macros.h"
+
+#ifdef USE_TLS
+
+COMMON_INT_DEF(foo);
+
+
+int
+in_dso (int n, int *caller_foop)
+{
+  int *foop = TLS_GD (foo);
+  int result = 0;
+
+  if (caller_foop != NULL && foop != caller_foop)
+    {
+      printf ("callers address of foo differs: %p vs %p\n", caller_foop, foop);
+      result = 1;
+    }
+  else if (*foop != n)
+    {
+      printf ("foo != %d\n", n);
+      result = 1;
+    }
+
+  *foop = 16;
+
+  return result;
+}
+#endif

include/link.h

@@ -259,10 +259,6 @@ struct link_map
 #ifdef USE_TLS
     /* Thread-local storage related info.  */
 
-    /* Next module in list of initialization images.  */
-    struct link_map *l_tls_nextimage;
-    /* Previous module in list of initialization images.  */
-    struct link_map *l_tls_previmage;
     /* Start of the initialization image.  */
     void *l_tls_initimage;
     /* Size of the initialization image.  */

include/stdlib.h

@@ -62,6 +62,8 @@ extern void __cxa_finalize (void *d);
 
 extern int __posix_memalign (void **memptr, size_t alignment, size_t size)
      __attribute_malloc__;
+extern void *__libc_memalign (size_t alignment, size_t size)
+     __attribute_malloc__;
 
 extern int __libc_system (const char *line);
 

linuxthreads/ChangeLog

@@ -1,8 +1,13 @@
+2002-02-12  Ulrich Drepper  <drepper@redhat.com>
+
+	* sysdeps/i386/tls.c (INSTALL_NEW_DTV): Define.
+	(INSTALL_DTV): Adjust for being passed pointer to element with length.
+
 2002-02-08  Ulrich Drepper  <drepper@redhat.com>
 
 	* sysdeps/i386/tls.h (TLS_INIT_TP): Also initialize %gs.
 
-2002-02-08  Richard Henderson  <rth@twiddle.net>
+2002-02-08  Richard Henderson  <rth@redhat.com>
 
 	* sysdeps/alpha/elf/pt-initfini.c: Use \n\ for multiline string.
 

linuxthreads/sysdeps/i386/tls.h

@@ -67,9 +67,15 @@ typedef struct
 # define TLS_TCB_AT_TP	1
 
 
-/* Install the dtv pointer.  */
+/* Install the dtv pointer.  The pointer passed is to the element with
+   index -1 which contain the length.  */
 # define INSTALL_DTV(descr, dtvp) \
-  ((tcbhead_t *) descr)->dtv = dtvp
+  ((tcbhead_t *) descr)->dtv = dtvp + 1
+
+/* Install new dtv for current thread.  */
+# define INSTALL_NEW_DTV(dtv) \
+  ({ struct _pthread_descr_struct *__descr;				      \
+     THREAD_SETMEM (__descr, p_header.data.dtvp, dtv); })
 
 /* Code to initially initialize the thread pointer.  This might need
    special attention since 'errno' is not yet available and if the

sysdeps/generic/dl-tls.c

@@ -18,8 +18,12 @@
    02111-1307 USA.  */
 
 #include <assert.h>
+#include <signal.h>
 #include <stdlib.h>
+#include <unistd.h>
+#include <sys/param.h>
 
+#include <abort-instr.h>
 #include <tls.h>
 
 /* We don't need any of this if TLS is not supported.  */
@@ -29,7 +33,31 @@
 #include <ldsodefs.h>
 
 /* Value used for dtv entries for which the allocation is delayed.  */
-# define TLS_DTV_UNALLOCATE	((void *) -1l)
+# define TLS_DTV_UNALLOCATED	((void *) -1l)
+
+
+/* Out-of-memory handler.  */
+static void
+__attribute__ ((__noreturn__))
+oom (void)
+{
+  static const char msg[] = "\
+cannot allocate memory for thread-local data: ABORT\n";
+
+  __libc_write (STDERR_FILENO, msg, sizeof (msg) - 1);
+
+  /* Kill ourself.  */
+  __kill (__getpid (), SIGKILL);
+
+  /* Just in case something goes wrong with the kill.  */
+  while (1)
+    {
+# ifdef ABORT_INSTRUCTION
+      ABORT_INSTRUCTION;
+# endif
+    }
+}
+
 
 
 size_t
@@ -40,38 +68,49 @@ _dl_next_tls_modid (void)
 
   if (__builtin_expect (GL(dl_tls_dtv_gaps), false))
     {
-      /* XXX If this method proves too costly we can optimize
+      size_t disp = 0;
-	 it to use a constant time method.  But I don't think
+      struct dtv_slotinfo_list *runp = GL(dl_tls_dtv_slotinfo_list);
-	 it's a problem.  */
-      struct link_map *runp = GL(dl_initimage_list);
-      bool used[GL(dl_tls_max_dtv_idx)];
 
-      assert (runp != NULL);
+      /* Note that this branch will never be executed during program
+	 start since there are no gaps at that time.  Therefore it
+	 does not matter that the dl_tls_dtv_slotinfo is not allocated
+	 yet when the function is called for the first times.  */
+      result = GL(dl_tls_static_nelem);
+      assert (result < GL(dl_tls_max_dtv_idx));
       do
 	{
-	  assert (runp->l_tls_modid > 0
+	  while (result - disp < runp->len)
-		  && runp->l_tls_modid <= GL(dl_tls_max_dtv_idx));
+	    if (runp->slotinfo[result - disp].map == NULL)
-	  used[runp->l_tls_modid - 1] = true;
-	}
-      while ((runp = runp->l_tls_nextimage) != GL(dl_initimage_list));
-
-      result = 0;
-      do
-	/* The information about the gaps is pessimistic.  It might be
-	   there are actually none.  */
-	if (result >= GL(dl_tls_max_dtv_idx))
-	  {
-	    /* Now we know there is actually no gap.  Bump the maximum
-	       ID number and remember that there are no gaps.  */
-	    result = ++GL(dl_tls_max_dtv_idx);
-	    GL(dl_tls_dtv_gaps) = false;
 	      break;
+
+	  ++result;
+	  assert (result <= GL(dl_tls_max_dtv_idx) + 1);
+
+	  if (result - disp < runp->len)
+	    break;
+
+	  disp += runp->len;
+	}
+      while ((runp = runp->next) != NULL);
+
+      if (result >= GL(dl_tls_max_dtv_idx) + 1)
+	{
+	  /* The new index must indeed be exactly one higher than the
+	     previous high.  */
+	  assert (result == GL(dl_tls_max_dtv_idx) + 1);
+
+	  /* There is no gap anymore.  */
+	  GL(dl_tls_dtv_gaps) = false;
+
+	  goto nogaps;
 	}
-      while (used[result++]);
     }
   else
+    {
       /* No gaps, allocate a new entry.  */
+    nogaps:
       result = ++GL(dl_tls_max_dtv_idx);
+    }
 
   return result;
 }
@@ -79,41 +118,39 @@ _dl_next_tls_modid (void)
 
 void
 internal_function
-_dl_determine_tlsoffset (struct link_map *lastp)
+_dl_determine_tlsoffset (void)
 {
-  struct link_map *runp;
+  struct dtv_slotinfo *slotinfo;
-  size_t max_align = 0;
+  size_t max_align = __alignof__ (void *);
   size_t offset;
+  size_t cnt;
 
-  if (lastp == NULL)
+  /* The first element of the dtv slot info list is allocated.  */
-    {
+  assert (GL(dl_tls_dtv_slotinfo_list) != NULL);
-      /* None of the objects used at startup time uses TLS.  We still
+  /* There is at this point only one element in the
-	 have to allocate the TCB and dtv.  */
+     dl_tls_dtv_slotinfo_list list.  */
-      GL(dl_tls_static_size) = TLS_TCB_SIZE;
+  assert (GL(dl_tls_dtv_slotinfo_list)->next == NULL);
-      GL(dl_tls_static_align) = TLS_TCB_ALIGN;
-
-      return;
-    }
 
 # if TLS_TCB_AT_TP
   /* We simply start with zero.  */
   offset = 0;
 
-  runp = lastp->l_tls_nextimage;
+  slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
-  do
+  for (cnt = 1; slotinfo[cnt].map != NULL; ++cnt)
     {
-      max_align = MAX (max_align, runp->l_tls_align);
+      assert (cnt < GL(dl_tls_dtv_slotinfo_list)->len);
+
+      max_align = MAX (max_align, slotinfo[cnt].map->l_tls_align);
 
       /* Compute the offset of the next TLS block.  */
-      offset = roundup (offset + runp->l_tls_blocksize, runp->l_tls_align);
+      offset = roundup (offset + slotinfo[cnt].map->l_tls_blocksize,
+			slotinfo[cnt].map->l_tls_align);
 
       /* XXX For some architectures we perhaps should store the
 	 negative offset.  */
-      runp->l_tls_offset = offset;
+      slotinfo[cnt].map->l_tls_offset = offset;
     }
-  while ((runp = runp->l_tls_nextimage) != lastp->l_tls_nextimage);
 
-#if 0
   /* The thread descriptor (pointed to by the thread pointer) has its
      own alignment requirement.  Adjust the static TLS size
      and TLS offsets appropriately.  */
@@ -121,34 +158,44 @@ _dl_determine_tlsoffset (struct link_map *lastp)
   // XXX after the first (closest to the TCB) TLS block since this
   // XXX would invalidate the offsets the linker creates for the LE
   // XXX model.
-  if (offset % TLS_TCB_ALIGN != 0)
-    abort ();
-#endif
 
   GL(dl_tls_static_size) = offset + TLS_TCB_SIZE;
 # elif TLS_DTV_AT_TP
-  struct link_map *prevp;
+  /* The TLS blocks start right after the TCB.  */
+  offset = TLS_TCB_SIZE;
 
   /* The first block starts right after the TCB.  */
-  offset = TLS_TCB_SIZE;
+  slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
-  max_align = runp->l_tls_align;
+  if (slotinfo[1].map != NULL)
-  runp = lastp->l_tls_nextimage;
-  runp->l_tls_offset = offset;
-  prevp = runp;
-
-  while ((runp = runp->l_tls_nextimage) != firstp)
     {
-      max_align = MAX (max_align, runp->l_tls_align);
+      size_t prev_size
+
+      offset = roundup (offset, slotinfo[1].map->l_tls_align);
+      slotinfo[1].map->l_tls_offset = offset;
+      max_align = slotinfo[1].map->l_tls_align;
+      prev_size = slotinfo[1].map->l_tls_blocksize;
+
+      for (cnt = 2; slotinfo[cnt].map != NULL; ++cnt)
+	{
+	  assert (cnt < GL(dl_tls_dtv_slotinfo_list)->len);
+
+	  max_align = MAX (max_align, slotinfo[cnt].map->l_tls_align);
 
 	  /* Compute the offset of the next TLS block.  */
-      offset = roundup (offset + prevp->l_tls_blocksize, runp->l_tls_align);
+	  offset = roundup (offset + prev_size,
+			    slotinfo[cnt].map->l_tls_align);
 
-      runp->l_tls_offset = offset;
+	  /* XXX For some architectures we perhaps should store the
+	     negative offset.  */
+	  slotinfo[cnt].map->l_tls_offset = offset;
 
-      prevp = runp;
+	  prev_size = slotinfo[cnt].map->l_tls_blocksize;
 	}
 
-  GL(dl_tls_static_size) = offset + prevp->l_tls_blocksize;
+      offset += prev_size;
+    }
+
+  GL(dl_tls_static_size) = offset;
 # else
 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 # endif
@@ -164,6 +211,7 @@ _dl_allocate_tls (void)
 {
   void *result;
   dtv_t *dtv;
+  size_t dtv_length;
 
   /* Allocate a correctly aligned chunk of memory.  */
   /* XXX For now */
@@ -179,44 +227,84 @@ _dl_allocate_tls (void)
   result = __mmap (0, GL(dl_tls_static_size), PROT_READ|PROT_WRITE,
 		   MAP_ANON|MAP_PRIVATE, _dl_zerofd, 0);
 
-  dtv = (dtv_t *) malloc ((GL(dl_tls_max_dtv_idx) + 1) * sizeof (dtv_t));
+  /* We allocate a few more elements in the dtv than are needed for the
+     initial set of modules.  This should avoid in most cases expansions
+     of the dtv.  */
+  dtv_length = GL(dl_tls_max_dtv_idx) + DTV_SURPLUS;
+  dtv = (dtv_t *) malloc ((dtv_length + 2) * sizeof (dtv_t));
   if (result != MAP_FAILED && dtv != NULL)
     {
-      struct link_map *runp;
+      struct dtv_slotinfo_list *listp;
+      bool first_block = true;
+      size_t total = 0;
 
 # if TLS_TCB_AT_TP
       /* The TCB follows the TLS blocks.  */
       result = (char *) result + GL(dl_tls_static_size) - TLS_TCB_SIZE;
 # endif
 
-      /* XXX Fill in an correct generation number.  */
+      /* This is the initial length of the dtv.  */
-      dtv[0].counter = 0;
+      dtv[0].counter = dtv_length;
+      /* Fill in the generation number.  */
+      dtv[1].counter = GL(dl_tls_generation) = 0;
+      /* Initialize all of the rest of the dtv with zero to indicate
+	 nothing there.  */
+      memset (dtv + 2, '\0', dtv_length * sizeof (dtv_t));
 
-      /* Initialize the memory from the initialization image list and clear
+      /* We have to look prepare the dtv for all currently loaded
-	 the BSS parts.  */
+	 modules using TLS.  For those which are dynamically loaded we
-      if (GL(dl_initimage_list) != NULL)
+	 add the values indicating deferred allocation.  */
+      listp = GL(dl_tls_dtv_slotinfo_list);
+      while (1)
 	{
-	  runp = GL(dl_initimage_list)->l_tls_nextimage;
+	  size_t cnt;
-	  do
+
+	  for (cnt = first_block ? 1 : 0; cnt < listp->len; ++cnt)
 	    {
-	      assert (runp->l_tls_modid > 0);
+	      struct link_map *map;
-	      assert (runp->l_tls_modid <= GL(dl_tls_max_dtv_idx));
+	      void *dest;
+
+	      /* Check for the total number of used slots.  */
+	      if (total + cnt >= GL(dl_tls_max_dtv_idx))
+		break;
+
+	      map = listp->slotinfo[cnt].map;
+	      if (map == NULL)
+		/* Unused entry.  */
+		continue;
+
+	      if (map->l_type == lt_loaded)
+		{
+		  /* For dynamically loaded modules we simply store
+		     the value indicating deferred allocation.  */
+		  dtv[1 + map->l_tls_modid].pointer = TLS_DTV_UNALLOCATED;
+		  continue;
+		}
+
+	      assert (map->l_tls_modid == cnt);
+	      assert (map->l_tls_blocksize >= map->l_tls_initimage_size);
 # if TLS_TCB_AT_TP
-	      dtv[runp->l_tls_modid].pointer = result - runp->l_tls_offset;
+	      assert (map->l_tls_offset >= map->l_tls_blocksize);
+	      dest = (char *) result - map->l_tls_offset;
 # elif TLS_DTV_AT_TP
-	      dtv[runp->l_tls_modid].pointer = result + runp->l_tls_offset;
+	      dest = (char *) result + map->l_tls_offset;
 # else
 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 # endif
 
-	      memset (__mempcpy (dtv[runp->l_tls_modid].pointer,
+	      /* We don't have to clear the BSS part of the TLS block
-				 runp->l_tls_initimage,
+		 since mmap is used to allocate the memory which
-				 runp->l_tls_initimage_size),
+		 guarantees it is initialized to zero.  */
-		      '\0',
+	      dtv[1 + cnt].pointer = memcpy (dest, map->l_tls_initimage,
-		      runp->l_tls_blocksize - runp->l_tls_initimage_size);
+					     map->l_tls_initimage_size);
 	    }
-	  while ((runp = runp->l_tls_nextimage)
+
-		 !=  GL(dl_initimage_list)->l_tls_nextimage);
+	  total += cnt;
+	  if (total >= GL(dl_tls_max_dtv_idx))
+	    break;
+
+	  listp = listp->next;
+	  assert (listp != NULL);
 	}
 
       /* Add the dtv to the thread data structures.  */
@@ -232,6 +320,7 @@ _dl_allocate_tls (void)
 }
 
 
+# ifdef SHARED
 /* The __tls_get_addr function has two basic forms which differ in the
    arguments.  The IA-64 form takes two parameters, the module ID and
    offset.  The form used, among others, on IA-32 takes a reference to
@@ -248,17 +337,218 @@ _dl_allocate_tls (void)
 #  ifndef GET_ADDR_OFFSET
 #   define GET_ADDR_OFFSET ti->ti_offset
 #  endif
+/* Systems which do not have tls_index also probably have to define
+   DONT_USE_TLS_INDEX.  */
+
+#  ifndef __TLS_GET_ADDR
+#   define __TLS_GET_ADDR __tls_get_addr
+#  endif
 
 
+/* Return the symbol address given the map of the module it is in and
+   the symbol record.  This is used in dl-sym.c.  */
+void *
+internal_function
+_dl_tls_symaddr (struct link_map *map, const ElfW(Sym) *ref)
+{
+#  ifndef DONT_USE_TLS_INDEX
+  tls_index tmp =
+    {
+      .ti_module = map->l_tls_modid,
+      .ti_offset = ref->st_value
+    };
+
+  return __TLS_GET_ADDR (&tmp);
+#  else
+  return __TLS_GET_ADDR (map->l_tls_modid, ref->st_value);
+#  endif
+}
+
+
+static void *
+allocate_and_init (struct link_map *map)
+{
+  void *newp;
+
+  newp = __libc_memalign (map->l_tls_align, map->l_tls_blocksize);
+  if (newp == NULL)
+    oom ();
+
+  /* Initialize the memory.  */
+  memset (__mempcpy (newp, map->l_tls_initimage, map->l_tls_initimage_size),
+	  '\0', map->l_tls_blocksize - map->l_tls_initimage_size);
+
+  return newp;
+}
+
+
+/* The generic dynamic and local dynamic model cannot be used in
+   statically linked applications.  */
 void *
 __tls_get_addr (GET_ADDR_ARGS)
 {
   dtv_t *dtv = THREAD_DTV ();
+  struct link_map *the_map = NULL;
+  void *p;
 
-  if (dtv[GET_ADDR_MODULE].pointer == TLS_DTV_UNALLOCATE)
+  if (__builtin_expect (dtv[0].counter != GL(dl_tls_generation), 0))
-    /* XXX */;
+    {
+      struct dtv_slotinfo_list *listp;
+      size_t idx;
 
-  return (char *) dtv[GET_ADDR_MODULE].pointer + GET_ADDR_OFFSET;
+      /* The global dl_tls_dtv_slotinfo array contains for each module
+	 index the generation counter current when the entry was
+	 created.  This array never shrinks so that all module indices
+	 which were valid at some time can be used to access it.
+	 Before the first use of a new module index in this function
+	 the array was extended appropriately.  Access also does not
+	 have to be guarded against modifications of the array.  It is
+	 assumed that pointer-size values can be read atomically even
+	 in SMP environments.  It is possible that other threads at
+	 the same time dynamically load code and therefore add to the
+	 slotinfo list.  This is a problem since we must not pick up
+	 any information about incomplete work.  The solution to this
+	 is to ignore all dtv slots which were created after the one
+	 we are currently interested.  We know that dynamic loading
+	 for this module is completed and this is the last load
+	 operation we know finished.  */
+      idx = GET_ADDR_MODULE;
+      listp = GL(dl_tls_dtv_slotinfo_list);
+      while (idx >= listp->len)
+	{
+	  idx -= listp->len;
+	  listp = listp->next;
 	}
 
+      if (dtv[0].counter < listp->slotinfo[idx].gen)
+	{
+	  /* The generation counter for the slot is higher than what
+	     the current dtv implements.  We have to update the whole
+	     dtv but only those entries with a generation counter <=
+	     the one for the entry we need.  */
+	  size_t new_gen = listp->slotinfo[idx].gen;
+	  size_t total = 0;
+
+	  /* We have to look through the entire dtv slotinfo list.  */
+	  listp =  GL(dl_tls_dtv_slotinfo_list);
+	  do
+	    {
+	      size_t cnt;
+
+	      for (cnt = total = 0 ? 1 : 0; cnt < listp->len; ++cnt)
+		{
+		  size_t gen = listp->slotinfo[cnt].gen;
+		  struct link_map *map;
+		  size_t modid;
+
+		  if (gen > new_gen)
+		    /* This is a slot for a generation younger than
+		       the one we are handling now.  It might be
+		       incompletely set up so ignore it.  */
+		    continue;
+
+		  /* If the entry is older than the current dtv layout
+		     we know we don't have to handle it.  */
+		  if (gen <= dtv[0].counter)
+		    continue;
+
+		  /* If there is no map this means the entry is empty.  */
+		  map = listp->slotinfo[cnt].map;
+		  if (map == NULL)
+		    {
+		      /* If this modid was used at some point the memory
+			 might still be allocated.  */
+		      if (dtv[total + cnt].pointer != TLS_DTV_UNALLOCATED)
+			free (dtv[total + cnt].pointer);
+
+		      continue;
+		    }
+
+		  /* Check whether the current dtv array is large enough.  */
+		  modid = map->l_tls_modid;
+		  assert (total + cnt == modid);
+		  if (dtv[-1].counter < modid)
+		    {
+		      /* Reallocate the dtv.  */
+		      dtv_t *newp;
+		      size_t newsize = GL(dl_tls_max_dtv_idx) + DTV_SURPLUS;
+		      size_t oldsize = dtv[-1].counter;
+
+		      assert (map->l_tls_modid <= newsize);
+
+		      newp = (dtv_t *) realloc (&dtv[-1],
+						(2 + newsize)
+						* sizeof (dtv_t));
+		      if (newp == NULL)
+			oom ();
+
+		      newp[0].counter = newsize;
+
+		      /* Clear the newly allocate part.  */
+		      memset (newp + 2 + oldsize, '\0',
+			      (newsize - oldsize) * sizeof (dtv_t));
+
+		      /* Point dtv to the generation counter.  */
+		      dtv = &newp[1];
+
+		      /* Install this new dtv in the thread data
+			 structures.  */
+		      INSTALL_NEW_DTV (dtv);
+		    }
+
+		  /* If there is currently memory allocate for this
+		     dtv entry free it.  */
+		  /* XXX Ideally we will at some point create a memory
+		     pool.  */
+		  if (dtv[modid].pointer != TLS_DTV_UNALLOCATED)
+		    /* Note that free is called for NULL is well.  We
+		       deallocate even if it is this dtv entry we are
+		       supposed to load.  The reason is that we call
+		       memalign and not malloc.  */
+		    free (dtv[modid].pointer);
+
+		  /* This module is loaded dynamically- We defer
+		     memory allocation.  */
+		  dtv[modid].pointer = TLS_DTV_UNALLOCATED;
+
+		  if (modid == GET_ADDR_MODULE)
+		    the_map = map;
+		}
+
+	      total += listp->len;
+	    }
+	  while ((listp = listp->next) != NULL);
+
+	  /* This will be the new maximum generation counter.  */
+	  dtv[0].counter = new_gen;
+	}
+    }
+
+  p = dtv[GET_ADDR_MODULE].pointer;
+
+  if (__builtin_expect (p == TLS_DTV_UNALLOCATED, 0))
+    {
+      /* The allocation was deferred.  Do it now.  */
+      if (the_map == NULL)
+	{
+	  /* Find the link map for this module.  */
+	  size_t idx = GET_ADDR_MODULE;
+	  struct dtv_slotinfo_list *listp = GL(dl_tls_dtv_slotinfo_list);
+
+	  while (idx >= listp->len)
+	    {
+	      idx -= listp->len;
+	      listp = listp->next;
+	    }
+
+	  the_map = listp->slotinfo[idx].map;
+	}
+
+      p = dtv[GET_ADDR_MODULE].pointer = allocate_and_init (the_map);
+    }
+
+  return (char *) p + GET_ADDR_OFFSET;
+}
+# endif
+
 #endif	/* use TLS */

sysdeps/generic/ldsodefs.h

@@ -289,23 +289,40 @@ struct rtld_global
 #endif
 
 #ifdef USE_TLS
-  /* Beginning of the list of link maps for objects which contain
-     thread-local storage sections.  This will be traversed to
-     initialize new TLS blocks.  */
-  EXTERN struct link_map *_dl_initimage_list;
-
   /* Highest dtv index currently needed.  */
   EXTERN size_t _dl_tls_max_dtv_idx;
   /* Flag signalling whether there are gaps in the module ID allocation.  */
   EXTERN bool _dl_tls_dtv_gaps;
-
+  /* Information about the dtv slots.  */
+  EXTERN struct dtv_slotinfo_list
+  {
+    size_t len;
+    struct dtv_slotinfo_list *next;
+    struct dtv_slotinfo
+    {
+      size_t gen;
+      struct link_map *map;
+    } slotinfo[0];
+  } *_dl_tls_dtv_slotinfo_list;
+  /* Number of modules in the static TLS block.  */
+  EXTERN size_t _dl_tls_static_nelem;
   /* Size of the static TLS block.  */
   EXTERN size_t _dl_tls_static_size;
   /* Alignment requirement of the static TLS block.  */
   EXTERN size_t _dl_tls_static_align;
 
+/* Number of additional entries in the slotinfo array of each slotinfo
+   list element.  A large number makes it almost certain take we never
+   have to iterate beyond the first element in the slotinfo list.  */
+# define TLS_SLOTINFO_SURPLUS (62)
+
+/* Number of additional slots in the dtv allocated.  */
+# define DTV_SURPLUS	(14)
+
   /* True if the dtv for the initial thread was malloc()ed.  */
   EXTERN bool _dl_initial_dtv_malloced;
+  /* Generation counter for the dtv.  */
+  EXTERN size_t _dl_tls_generation;
 #endif
 
   /* Name of the shared object to be profiled (if any).  */
@@ -667,12 +684,16 @@ extern void _dl_sysdep_start_cleanup (void)
 extern size_t _dl_next_tls_modid (void) internal_function;
 
 /* Calculate offset of the TLS blocks in the static TLS block.  */
-extern void _dl_determine_tlsoffset (struct link_map *firstp)
+extern void _dl_determine_tlsoffset (void) internal_function;
-     internal_function;
 
 /* Allocate memory for static TLS block and dtv.  */
 extern void *_dl_allocate_tls (void) internal_function;
 
+/* Return the symbol address given the map of the module it is in and
+   the symbol record.  */
+extern void *_dl_tls_symaddr (struct link_map *map, const ElfW(Sym) *ref)
+     internal_function;
+
 __END_DECLS
 
 #endif /* ldsodefs.h */

sysdeps/i386/dl-tls.h

@@ -17,6 +17,7 @@
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
+
 /* Type used for the representation of TLS information in the GOT.  */
 typedef struct
 {
@@ -25,6 +26,7 @@ typedef struct
 } tls_index;
 
 
+#ifdef SHARED
 /* This is the prototype for the GNU version.  */
 extern void *___tls_get_addr (tls_index *ti)
      __attribute__ ((__regparm__ (1)));
@@ -48,3 +50,5 @@ __tls_get_addr (tls_index *ti)
    version of this file.  */
 # define __tls_get_addr __attribute__ ((__regparm__ (1))) ___tls_get_addr
 strong_alias (___tls_get_addr, ___tls_get_addr_internal)
+# define __TLS_GET_ADDR ___tls_get_addr
+#endif