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