(_dl_determine_tlsoffset): Fix tls offset computation for TCB_AT_TP.
[kopensolaris-gnu/glibc.git] / sysdeps / generic / dl-tls.c
1 /* Thread-local storage handling in the ELF dynamic linker.  Generic version.
2    Copyright (C) 2002, 2003 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <assert.h>
21 #include <signal.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24 #include <sys/param.h>
25
26 #include <tls.h>
27
28 /* We don't need any of this if TLS is not supported.  */
29 #ifdef USE_TLS
30
31 # include <dl-tls.h>
32 # include <ldsodefs.h>
33
34 /* Amount of excess space to allocate in the static TLS area
35    to allow dynamic loading of modules defining IE-model TLS data.  */
36 # define TLS_STATIC_SURPLUS     64
37
38 /* Value used for dtv entries for which the allocation is delayed.  */
39 # define TLS_DTV_UNALLOCATED    ((void *) -1l)
40
41
42 /* Out-of-memory handler.  */
43 # ifdef SHARED
44 static void
45 __attribute__ ((__noreturn__))
46 oom (void)
47 {
48   _dl_fatal_printf ("cannot allocate memory for thread-local data: ABORT\n");
49 }
50 # endif
51
52
53
54 size_t
55 internal_function
56 _dl_next_tls_modid (void)
57 {
58   size_t result;
59
60   if (__builtin_expect (GL(dl_tls_dtv_gaps), false))
61     {
62       size_t disp = 0;
63       struct dtv_slotinfo_list *runp = GL(dl_tls_dtv_slotinfo_list);
64
65       /* Note that this branch will never be executed during program
66          start since there are no gaps at that time.  Therefore it
67          does not matter that the dl_tls_dtv_slotinfo is not allocated
68          yet when the function is called for the first times.  */
69       result = GL(dl_tls_static_nelem) + 1;
70       /* If the following would not be true we mustn't have assumed
71          there is a gap.  */
72       assert (result <= GL(dl_tls_max_dtv_idx));
73       do
74         {
75           while (result - disp < runp->len)
76             {
77               if (runp->slotinfo[result - disp].map == NULL)
78                 break;
79
80               ++result;
81               assert (result <= GL(dl_tls_max_dtv_idx) + 1);
82             }
83
84           if (result - disp < runp->len)
85             break;
86
87           disp += runp->len;
88         }
89       while ((runp = runp->next) != NULL);
90
91       if (result >= GL(dl_tls_max_dtv_idx))
92         {
93           /* The new index must indeed be exactly one higher than the
94              previous high.  */
95           assert (result == GL(dl_tls_max_dtv_idx));
96
97           /* There is no gap anymore.  */
98           GL(dl_tls_dtv_gaps) = false;
99
100           goto nogaps;
101         }
102     }
103   else
104     {
105       /* No gaps, allocate a new entry.  */
106     nogaps:
107       result = ++GL(dl_tls_max_dtv_idx);
108     }
109
110   return result;
111 }
112
113 # ifdef SHARED
114
115 void
116 internal_function
117 _dl_determine_tlsoffset (void)
118 {
119   struct dtv_slotinfo *slotinfo;
120   size_t max_align = TLS_TCB_ALIGN;
121   size_t offset, freetop = 0, freebottom = 0;
122   size_t cnt;
123
124   /* The first element of the dtv slot info list is allocated.  */
125   assert (GL(dl_tls_dtv_slotinfo_list) != NULL);
126   /* There is at this point only one element in the
127      dl_tls_dtv_slotinfo_list list.  */
128   assert (GL(dl_tls_dtv_slotinfo_list)->next == NULL);
129
130   slotinfo = GL(dl_tls_dtv_slotinfo_list)->slotinfo;
131
132   /* Determining the offset of the various parts of the static TLS
133      block has several dependencies.  In addition we have to work
134      around bugs in some toolchains.
135
136      Each TLS block from the objects available at link time has a size
137      and an alignment requirement.  The GNU ld computes the alignment
138      requirements for the data at the positions *in the file*, though.
139      I.e, it is not simply possible to allocate a block with the size
140      of the TLS program header entry.  The data is layed out assuming
141      that the first byte of the TLS block fulfills
142
143        p_vaddr mod p_align == &TLS_BLOCK mod p_align
144
145      This means we have to add artificial padding at the beginning of
146      the TLS block.  These bytes are never used for the TLS data in
147      this module but the first byte allocated must be aligned
148      according to mod p_align == 0 so that the first byte of the TLS
149      block is aligned according to p_vaddr mod p_align.  This is ugly
150      and the linker can help by computing the offsets in the TLS block
151      assuming the first byte of the TLS block is aligned according to
152      p_align.
153
154      The extra space which might be allocated before the first byte of
155      the TLS block need not go unused.  The code below tries to use
156      that memory for the next TLS block.  This can work if the total
157      memory requirement for the next TLS block is smaller than the
158      gap.  */
159
160 # if TLS_TCB_AT_TP
161   /* We simply start with zero.  */
162   offset = 0;
163
164   for (cnt = 1; slotinfo[cnt].map != NULL; ++cnt)
165     {
166       assert (cnt < GL(dl_tls_dtv_slotinfo_list)->len);
167
168       size_t firstbyte = (-slotinfo[cnt].map->l_tls_firstbyte_offset
169                           & (slotinfo[cnt].map->l_tls_align - 1));
170       size_t off;
171       max_align = MAX (max_align, slotinfo[cnt].map->l_tls_align);
172
173       if (freebottom - freetop >= slotinfo[cnt].map->l_tls_blocksize)
174         {
175           off = roundup (freetop + slotinfo[cnt].map->l_tls_blocksize
176                          - firstbyte, slotinfo[cnt].map->l_tls_align)
177                 + firstbyte;
178           if (off <= freebottom)
179             {
180               freetop = off;
181
182               /* XXX For some architectures we perhaps should store the
183                  negative offset.  */
184               slotinfo[cnt].map->l_tls_offset = off;
185               continue;
186             }
187         }
188
189       off = roundup (offset + slotinfo[cnt].map->l_tls_blocksize - firstbyte,
190                      slotinfo[cnt].map->l_tls_align) + firstbyte;
191       if (off > offset + slotinfo[cnt].map->l_tls_blocksize
192                 + (freebottom - freetop))
193         {
194           freetop = offset;
195           freebottom = off - slotinfo[cnt].map->l_tls_blocksize;
196         }
197       offset = off;
198
199       /* XXX For some architectures we perhaps should store the
200          negative offset.  */
201       slotinfo[cnt].map->l_tls_offset = off;
202     }
203
204   GL(dl_tls_static_used) = offset;
205   GL(dl_tls_static_size) = (roundup (offset + TLS_STATIC_SURPLUS, max_align)
206                             + TLS_TCB_SIZE);
207 # elif TLS_DTV_AT_TP
208   /* The TLS blocks start right after the TCB.  */
209   offset = TLS_TCB_SIZE;
210
211   for (cnt = 1; slotinfo[cnt].map != NULL; ++cnt)
212     {
213       assert (cnt < GL(dl_tls_dtv_slotinfo_list)->len);
214
215       size_t firstbyte = (-slotinfo[cnt].map->l_tls_firstbyte_offset
216                           & (slotinfo[cnt].map->l_tls_align - 1));
217       size_t off;
218       max_align = MAX (max_align, slotinfo[cnt].map->l_tls_align);
219
220       if (slotinfo[cnt].map->l_tls_blocksize >= freetop - freebottom)
221         {
222           off = roundup (freebottom, slotinfo[cnt].map->l_tls_align);
223           if (off - freebottom < firstbyte)
224             off += slotinfo[cnt].map->l_tls_align;
225           if (off + slotinfo[cnt].map->l_tls_blocksize - firstbyte <= freetop)
226             {
227               slotinfo[cnt].map->l_tls_offset = off - firstbyte;
228               freebottom = off + slotinfo[cnt].map->l_tls_blocksize
229                            - firstbyte;
230               continue;
231             }
232         }
233
234       off = roundup (offset, slotinfo[cnt].map->l_tls_align);
235       if (off - offset < firstbyte)
236         off += slotinfo[cnt].map->l_tls_align;
237
238       slotinfo[cnt].map->l_tls_offset = off - firstbyte;
239       if (off - firstbyte - offset > freetop - freebottom)
240         {
241           freebottom = offset;
242           freetop = off - firstbyte;
243         }
244
245       offset = off + slotinfo[cnt].map->l_tls_blocksize - firstbyte;
246     }
247
248   GL(dl_tls_static_used) = offset;
249   GL(dl_tls_static_size) = roundup (offset + TLS_STATIC_SURPLUS,
250                                     TLS_TCB_ALIGN);
251 # else
252 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
253 # endif
254
255   /* The alignment requirement for the static TLS block.  */
256   GL(dl_tls_static_align) = max_align;
257 }
258
259
260 /* This is called only when the data structure setup was skipped at startup,
261    when there was no need for it then.  Now we have dynamically loaded
262    something needing TLS, or libpthread needs it.  */
263 int
264 internal_function
265 _dl_tls_setup (void)
266 {
267   assert (GL(dl_tls_dtv_slotinfo_list) == NULL);
268   assert (GL(dl_tls_max_dtv_idx) == 0);
269
270   const size_t nelem = 2 + TLS_SLOTINFO_SURPLUS;
271
272   GL(dl_tls_dtv_slotinfo_list)
273     = calloc (1, (sizeof (struct dtv_slotinfo_list)
274                   + nelem * sizeof (struct dtv_slotinfo)));
275   if (GL(dl_tls_dtv_slotinfo_list) == NULL)
276     return -1;
277
278   GL(dl_tls_dtv_slotinfo_list)->len = nelem;
279
280   /* Number of elements in the static TLS block.  It can't be zero
281      because of various assumptions.  The one element is null.  */
282   GL(dl_tls_static_nelem) = GL(dl_tls_max_dtv_idx) = 1;
283
284   /* This initializes more variables for us.  */
285   _dl_determine_tlsoffset ();
286
287   return 0;
288 }
289 rtld_hidden_def (_dl_tls_setup)
290 # endif
291
292 static void *
293 internal_function
294 allocate_dtv (void *result)
295 {
296   dtv_t *dtv;
297   size_t dtv_length;
298
299   /* We allocate a few more elements in the dtv than are needed for the
300      initial set of modules.  This should avoid in most cases expansions
301      of the dtv.  */
302   dtv_length = GL(dl_tls_max_dtv_idx) + DTV_SURPLUS;
303   dtv = calloc (dtv_length + 2, sizeof (dtv_t));
304   if (dtv != NULL)
305     {
306       /* This is the initial length of the dtv.  */
307       dtv[0].counter = dtv_length;
308
309       /* The rest of the dtv (including the generation counter) is
310          Initialize with zero to indicate nothing there.  */
311
312       /* Add the dtv to the thread data structures.  */
313       INSTALL_DTV (result, dtv);
314     }
315   else
316     result = NULL;
317
318   return result;
319 }
320
321
322 /* Get size and alignment requirements of the static TLS block.  */
323 void
324 internal_function
325 _dl_get_tls_static_info (size_t *sizep, size_t *alignp)
326 {
327   *sizep = GL(dl_tls_static_size);
328   *alignp = GL(dl_tls_static_align);
329 }
330
331
332 void *
333 internal_function
334 _dl_allocate_tls_storage (void)
335 {
336   void *result;
337   size_t size = GL(dl_tls_static_size);
338
339 # if TLS_DTV_AT_TP
340   /* Memory layout is:
341      [ TLS_PRE_TCB_SIZE ] [ TLS_TCB_SIZE ] [ TLS blocks ]
342                           ^ This should be returned.  */
343   size += (TLS_PRE_TCB_SIZE + GL(dl_tls_static_align) - 1)
344           & ~(GL(dl_tls_static_align) - 1);
345 # endif
346
347   /* Allocate a correctly aligned chunk of memory.  */
348   result = __libc_memalign (GL(dl_tls_static_align), size);
349   if (__builtin_expect (result != NULL, 1))
350     {
351       /* Allocate the DTV.  */
352       void *allocated = result;
353
354 # if TLS_TCB_AT_TP
355       /* The TCB follows the TLS blocks.  */
356       result = (char *) result + size - TLS_TCB_SIZE;
357
358       /* Clear the TCB data structure.  We can't ask the caller (i.e.
359          libpthread) to do it, because we will initialize the DTV et al.  */
360       memset (result, 0, TLS_TCB_SIZE);
361 # elif TLS_DTV_AT_TP
362       result = (char *) result + size - GL(dl_tls_static_size);
363
364       /* Clear the TCB data structure and TLS_PRE_TCB_SIZE bytes before it.
365          We can't ask the caller (i.e. libpthread) to do it, because we will
366          initialize the DTV et al.  */
367       memset ((char *) result - TLS_PRE_TCB_SIZE, 0,
368               TLS_PRE_TCB_SIZE + TLS_TCB_SIZE);
369 # endif
370
371       result = allocate_dtv (result);
372       if (result == NULL)
373         free (allocated);
374     }
375
376   return result;
377 }
378
379
380 void *
381 internal_function
382 _dl_allocate_tls_init (void *result)
383 {
384   if (result == NULL)
385     /* The memory allocation failed.  */
386     return NULL;
387
388   dtv_t *dtv = GET_DTV (result);
389   struct dtv_slotinfo_list *listp;
390   size_t total = 0;
391
392   /* We have to look prepare the dtv for all currently loaded
393      modules using TLS.  For those which are dynamically loaded we
394      add the values indicating deferred allocation.  */
395   listp = GL(dl_tls_dtv_slotinfo_list);
396   while (1)
397     {
398       size_t cnt;
399
400       for (cnt = total == 0 ? 1 : 0; cnt < listp->len; ++cnt)
401         {
402           struct link_map *map;
403           void *dest;
404
405           /* Check for the total number of used slots.  */
406           if (total + cnt > GL(dl_tls_max_dtv_idx))
407             break;
408
409           map = listp->slotinfo[cnt].map;
410           if (map == NULL)
411             /* Unused entry.  */
412             continue;
413
414           if (map->l_tls_offset == NO_TLS_OFFSET)
415             {
416               /* For dynamically loaded modules we simply store
417                  the value indicating deferred allocation.  */
418               dtv[map->l_tls_modid].pointer = TLS_DTV_UNALLOCATED;
419               continue;
420             }
421
422           assert (map->l_tls_modid == cnt);
423           assert (map->l_tls_blocksize >= map->l_tls_initimage_size);
424 # if TLS_TCB_AT_TP
425           assert ((size_t) map->l_tls_offset >= map->l_tls_blocksize);
426           dest = (char *) result - map->l_tls_offset;
427 # elif TLS_DTV_AT_TP
428           dest = (char *) result + map->l_tls_offset;
429 # else
430 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
431 # endif
432
433           /* Copy the initialization image and clear the BSS part.  */
434           dtv[map->l_tls_modid].pointer = dest;
435           memset (__mempcpy (dest, map->l_tls_initimage,
436                              map->l_tls_initimage_size), '\0',
437                   map->l_tls_blocksize - map->l_tls_initimage_size);
438         }
439
440       total += cnt;
441       if (total >= GL(dl_tls_max_dtv_idx))
442         break;
443
444       listp = listp->next;
445       assert (listp != NULL);
446     }
447
448   return result;
449 }
450 rtld_hidden_def (_dl_allocate_tls_init)
451
452 void *
453 internal_function
454 _dl_allocate_tls (void *mem)
455 {
456   return _dl_allocate_tls_init (mem == NULL
457                                 ? _dl_allocate_tls_storage ()
458                                 : allocate_dtv (mem));
459 }
460 rtld_hidden_def (_dl_allocate_tls)
461
462
463 void
464 internal_function
465 _dl_deallocate_tls (void *tcb, bool dealloc_tcb)
466 {
467   dtv_t *dtv = GET_DTV (tcb);
468
469   /* The array starts with dtv[-1].  */
470 #ifdef SHARED
471   if (dtv != GL(dl_initial_dtv))
472 #endif
473     free (dtv - 1);
474
475   if (dealloc_tcb)
476     {
477 # if TLS_TCB_AT_TP
478       /* The TCB follows the TLS blocks.  Back up to free the whole block.  */
479       tcb -= GL(dl_tls_static_size) - TLS_TCB_SIZE;
480 # elif TLS_DTV_AT_TP
481       /* Back up the TLS_PRE_TCB_SIZE bytes.  */
482       tcb -= (TLS_PRE_TCB_SIZE + GL(dl_tls_static_align) - 1)
483              & ~(GL(dl_tls_static_align) - 1);
484 # endif
485       free (tcb);
486     }
487 }
488 rtld_hidden_def (_dl_deallocate_tls)
489
490
491 # ifdef SHARED
492 /* The __tls_get_addr function has two basic forms which differ in the
493    arguments.  The IA-64 form takes two parameters, the module ID and
494    offset.  The form used, among others, on IA-32 takes a reference to
495    a special structure which contain the same information.  The second
496    form seems to be more often used (in the moment) so we default to
497    it.  Users of the IA-64 form have to provide adequate definitions
498    of the following macros.  */
499 #  ifndef GET_ADDR_ARGS
500 #   define GET_ADDR_ARGS tls_index *ti
501 #  endif
502 #  ifndef GET_ADDR_MODULE
503 #   define GET_ADDR_MODULE ti->ti_module
504 #  endif
505 #  ifndef GET_ADDR_OFFSET
506 #   define GET_ADDR_OFFSET ti->ti_offset
507 #  endif
508 /* Systems which do not have tls_index also probably have to define
509    DONT_USE_TLS_INDEX.  */
510
511 #  ifndef __TLS_GET_ADDR
512 #   define __TLS_GET_ADDR __tls_get_addr
513 #  endif
514
515
516 /* Return the symbol address given the map of the module it is in and
517    the symbol record.  This is used in dl-sym.c.  */
518 void *
519 internal_function
520 _dl_tls_symaddr (struct link_map *map, const ElfW(Sym) *ref)
521 {
522 #  ifndef DONT_USE_TLS_INDEX
523   tls_index tmp =
524     {
525       .ti_module = map->l_tls_modid,
526       .ti_offset = ref->st_value
527     };
528
529   return __TLS_GET_ADDR (&tmp);
530 #  else
531   return __TLS_GET_ADDR (map->l_tls_modid, ref->st_value);
532 #  endif
533 }
534
535
536 static void *
537 allocate_and_init (struct link_map *map)
538 {
539   void *newp;
540
541   newp = __libc_memalign (map->l_tls_align, map->l_tls_blocksize);
542   if (newp == NULL)
543     oom ();
544
545   /* Initialize the memory.  */
546   memset (__mempcpy (newp, map->l_tls_initimage, map->l_tls_initimage_size),
547           '\0', map->l_tls_blocksize - map->l_tls_initimage_size);
548
549   return newp;
550 }
551
552
553 /* The generic dynamic and local dynamic model cannot be used in
554    statically linked applications.  */
555 void *
556 __tls_get_addr (GET_ADDR_ARGS)
557 {
558   dtv_t *dtv = THREAD_DTV ();
559   struct link_map *the_map = NULL;
560   void *p;
561
562   if (__builtin_expect (dtv[0].counter != GL(dl_tls_generation), 0))
563     {
564       struct dtv_slotinfo_list *listp;
565       size_t idx;
566
567       /* The global dl_tls_dtv_slotinfo array contains for each module
568          index the generation counter current when the entry was
569          created.  This array never shrinks so that all module indices
570          which were valid at some time can be used to access it.
571          Before the first use of a new module index in this function
572          the array was extended appropriately.  Access also does not
573          have to be guarded against modifications of the array.  It is
574          assumed that pointer-size values can be read atomically even
575          in SMP environments.  It is possible that other threads at
576          the same time dynamically load code and therefore add to the
577          slotinfo list.  This is a problem since we must not pick up
578          any information about incomplete work.  The solution to this
579          is to ignore all dtv slots which were created after the one
580          we are currently interested.  We know that dynamic loading
581          for this module is completed and this is the last load
582          operation we know finished.  */
583       idx = GET_ADDR_MODULE;
584       listp = GL(dl_tls_dtv_slotinfo_list);
585       while (idx >= listp->len)
586         {
587           idx -= listp->len;
588           listp = listp->next;
589         }
590
591       if (dtv[0].counter < listp->slotinfo[idx].gen)
592         {
593           /* The generation counter for the slot is higher than what
594              the current dtv implements.  We have to update the whole
595              dtv but only those entries with a generation counter <=
596              the one for the entry we need.  */
597           size_t new_gen = listp->slotinfo[idx].gen;
598           size_t total = 0;
599
600           /* We have to look through the entire dtv slotinfo list.  */
601           listp =  GL(dl_tls_dtv_slotinfo_list);
602           do
603             {
604               size_t cnt;
605
606               for (cnt = total = 0 ? 1 : 0; cnt < listp->len; ++cnt)
607                 {
608                   size_t gen = listp->slotinfo[cnt].gen;
609                   struct link_map *map;
610                   size_t modid;
611
612                   if (gen > new_gen)
613                     /* This is a slot for a generation younger than
614                        the one we are handling now.  It might be
615                        incompletely set up so ignore it.  */
616                     continue;
617
618                   /* If the entry is older than the current dtv layout
619                      we know we don't have to handle it.  */
620                   if (gen <= dtv[0].counter)
621                     continue;
622
623                   /* If there is no map this means the entry is empty.  */
624                   map = listp->slotinfo[cnt].map;
625                   if (map == NULL)
626                     {
627                       /* If this modid was used at some point the memory
628                          might still be allocated.  */
629                       if (dtv[total + cnt].pointer != TLS_DTV_UNALLOCATED)
630                         {
631                           free (dtv[total + cnt].pointer);
632                           dtv[total + cnt].pointer = TLS_DTV_UNALLOCATED;
633                         }
634
635                       continue;
636                     }
637
638                   /* Check whether the current dtv array is large enough.  */
639                   modid = map->l_tls_modid;
640                   assert (total + cnt == modid);
641                   if (dtv[-1].counter < modid)
642                     {
643                       /* Reallocate the dtv.  */
644                       dtv_t *newp;
645                       size_t newsize = GL(dl_tls_max_dtv_idx) + DTV_SURPLUS;
646                       size_t oldsize = dtv[-1].counter;
647
648                       assert (map->l_tls_modid <= newsize);
649
650                       if (dtv == GL(dl_initial_dtv))
651                         {
652                           /* This is the initial dtv that was allocated
653                              during rtld startup using the dl-minimal.c
654                              malloc instead of the real malloc.  We can't
655                              free it, we have to abandon the old storage.  */
656
657                           newp = malloc ((2 + newsize) * sizeof (dtv_t));
658                           if (newp == NULL)
659                             oom ();
660                           memcpy (newp, &dtv[-1], oldsize * sizeof (dtv_t));
661                         }
662                       else
663                         {
664                           newp = realloc (&dtv[-1],
665                                           (2 + newsize) * sizeof (dtv_t));
666                           if (newp == NULL)
667                             oom ();
668                         }
669
670                       newp[0].counter = newsize;
671
672                       /* Clear the newly allocated part.  */
673                       memset (newp + 2 + oldsize, '\0',
674                               (newsize - oldsize) * sizeof (dtv_t));
675
676                       /* Point dtv to the generation counter.  */
677                       dtv = &newp[1];
678
679                       /* Install this new dtv in the thread data
680                          structures.  */
681                       INSTALL_NEW_DTV (dtv);
682                     }
683
684                   /* If there is currently memory allocate for this
685                      dtv entry free it.  */
686                   /* XXX Ideally we will at some point create a memory
687                      pool.  */
688                   if (dtv[modid].pointer != TLS_DTV_UNALLOCATED)
689                     /* Note that free is called for NULL is well.  We
690                        deallocate even if it is this dtv entry we are
691                        supposed to load.  The reason is that we call
692                        memalign and not malloc.  */
693                     free (dtv[modid].pointer);
694
695                   /* This module is loaded dynamically- We defer
696                      memory allocation.  */
697                   dtv[modid].pointer = TLS_DTV_UNALLOCATED;
698
699                   if (modid == GET_ADDR_MODULE)
700                     the_map = map;
701                 }
702
703               total += listp->len;
704             }
705           while ((listp = listp->next) != NULL);
706
707           /* This will be the new maximum generation counter.  */
708           dtv[0].counter = new_gen;
709         }
710     }
711
712   p = dtv[GET_ADDR_MODULE].pointer;
713
714   if (__builtin_expect (p == TLS_DTV_UNALLOCATED, 0))
715     {
716       /* The allocation was deferred.  Do it now.  */
717       if (the_map == NULL)
718         {
719           /* Find the link map for this module.  */
720           size_t idx = GET_ADDR_MODULE;
721           struct dtv_slotinfo_list *listp = GL(dl_tls_dtv_slotinfo_list);
722
723           while (idx >= listp->len)
724             {
725               idx -= listp->len;
726               listp = listp->next;
727             }
728
729           the_map = listp->slotinfo[idx].map;
730         }
731
732       p = dtv[GET_ADDR_MODULE].pointer = allocate_and_init (the_map);
733     }
734
735   return (char *) p + GET_ADDR_OFFSET;
736 }
737 # endif
738
739 #endif  /* use TLS */