← Back to branch summary

~ubuntu-branches/ubuntu/utopic/eglibc/utopic

« back to all changes in this revision

Viewing changes to .pc/i386/submitted-i686-timing.diff/sysdeps/generic/ldsodefs.h

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2012-10-26 05:14:58 UTC
  • mfrom: (1.5.1) (4.4.22 experimental)
  • Revision ID: package-import@ubuntu.com-20121026051458-oryotr4i03ob5pab
Tags: 2.16-0ubuntu1
* Merge with unreleased 2.16 in Debian experimental, remaining changes:
  - Drop the Breaks line from libc6, which refers to a Debian transition
  - Remove the libc6 recommends on libc6-i686, which we don't build
  - Enable libc6{,-dev}-armel on armhf and libc6{-dev}-armhf on armel
  - Ship update-locale and validlocale in /usr/sbin in libc-bin
  - Don't build locales or locales-all in Ubuntu, we rely on langpacks
  - Heavily mangle the way we do service restarting on major upgrades
  - Use different MIN_KERNEL_SUPPORTED versions than Debian, due to
    buildd needs.  This should be universally bumped to 3.2.0 once all
    our buildds (including the PPA guests) are running precise kernels
  - Build i386 variants as -march=i686, build amd64 with -O3, and build
    ppc64 variants (both 64-bit and 32-bit) with -O3 -fno-tree-vectorize
  - Re-enable unsubmitted-ldconfig-cache-abi.diff and rebuild the cache
    on upgrades from previous versions that used a different constant
  - debian/patches/any/local-CVE-2012-3406.diff: switch to malloc when
    array grows too large to handle via alloca extension (CVE-2012-3406)
  - Build generic i386/i686 flavour with -mno-tls-direct-seg-refs
* Changes added/dropped with this merge while reducing our delta:
  - Stop building glibc docs from the eglibc source, and instead make
    the glibc-docs stub have a hard dependency on glibc-doc-reference
  - Remove outdated conflicts against ancient versions of ia32-libs
  - Drop the tzdata dependency from libc6, it's in required and minimal
  - Use gcc-4.7/g++-4.7 by default on all our supported architectures
  - Save our historical changelog as changelog.ubuntu in the source
  - Drop nscd's libaudit build-dep for now, as libaudit is in universe
  - Drop the unnecessary Breaks from libc6 to locales and locales-all
  - Ship xen's ld.so.conf.d snippet as /etc/ld.so.conf.d/libc6-xen.conf
* Disable hard failures on the test suite for the first upload to raring

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/i386/submitted-i686-timing.diff/sysdeps/generic/ldsodefs.h
 
1
/* Run-time dynamic linker data structures for loaded ELF shared objects.
 
2
   Copyright (C) 1995-2012 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, see
 
17
   <http://www.gnu.org/licenses/>.  */
 
18
 
 
19
#ifndef _LDSODEFS_H
 
20
#define _LDSODEFS_H     1
 
21
 
 
22
#include <features.h>
 
23
 
 
24
#include <stdbool.h>
 
25
#define __need_size_t
 
26
#define __need_NULL
 
27
#include <stddef.h>
 
28
#include <string.h>
 
29
 
 
30
#include <elf.h>
 
31
#include <dlfcn.h>
 
32
#include <fpu_control.h>
 
33
#include <sys/mman.h>
 
34
#include <link.h>
 
35
#include <dl-lookupcfg.h>
 
36
#include <dl-sysdep.h>
 
37
#include <bits/libc-lock.h>
 
38
#include <hp-timing.h>
 
39
#include <tls.h>
 
40
#include <kernel-features.h>
 
41
 
 
42
__BEGIN_DECLS
 
43
 
 
44
/* We use this macro to refer to ELF types independent of the native wordsize.
 
45
   `ElfW(TYPE)' is used in place of `Elf32_TYPE' or `Elf64_TYPE'.  */
 
46
#define ELFW(type)      _ElfW (ELF, __ELF_NATIVE_CLASS, type)
 
47
 
 
48
/* All references to the value of l_info[DT_PLTGOT],
 
49
  l_info[DT_STRTAB], l_info[DT_SYMTAB], l_info[DT_RELA],
 
50
  l_info[DT_REL], l_info[DT_JMPREL], and l_info[VERSYMIDX (DT_VERSYM)]
 
51
  have to be accessed via the D_PTR macro.  The macro is needed since for
 
52
  most architectures the entry is already relocated - but for some not
 
53
  and we need to relocate at access time.  */
 
54
#ifdef DL_RO_DYN_SECTION
 
55
# define D_PTR(map, i) ((map)->i->d_un.d_ptr + (map)->l_addr)
 
56
#else
 
57
# define D_PTR(map, i) (map)->i->d_un.d_ptr
 
58
#endif
 
59
 
 
60
/* Result of the lookup functions and how to retrieve the base address.  */
 
61
typedef struct link_map *lookup_t;
 
62
#define LOOKUP_VALUE(map) map
 
63
#define LOOKUP_VALUE_ADDRESS(map) ((map) ? (map)->l_addr : 0)
 
64
 
 
65
/* On some architectures a pointer to a function is not just a pointer
 
66
   to the actual code of the function but rather an architecture
 
67
   specific descriptor. */
 
68
#ifndef ELF_FUNCTION_PTR_IS_SPECIAL
 
69
# define DL_SYMBOL_ADDRESS(map, ref) \
 
70
 (void *) (LOOKUP_VALUE_ADDRESS (map) + ref->st_value)
 
71
# define DL_LOOKUP_ADDRESS(addr) ((ElfW(Addr)) (addr))
 
72
# define DL_DT_INIT_ADDRESS(map, start) (start)
 
73
# define DL_DT_FINI_ADDRESS(map, start) (start)
 
74
#endif
 
75
 
 
76
/* On some architectures dladdr can't use st_size of all symbols this way.  */
 
77
#define DL_ADDR_SYM_MATCH(L, SYM, MATCHSYM, ADDR) \
 
78
  ((ADDR) >= (L)->l_addr + (SYM)->st_value                              \
 
79
   && ((((SYM)->st_shndx == SHN_UNDEF || (SYM)->st_size == 0)           \
 
80
        && (ADDR) == (L)->l_addr + (SYM)->st_value)                     \
 
81
       || (ADDR) < (L)->l_addr + (SYM)->st_value + (SYM)->st_size)      \
 
82
   && ((MATCHSYM) == NULL || (MATCHSYM)->st_value < (SYM)->st_value))
 
83
 
 
84
/* Unmap a loaded object, called by _dl_close (). */
 
85
#ifndef DL_UNMAP_IS_SPECIAL
 
86
# define DL_UNMAP(map) \
 
87
 __munmap ((void *) (map)->l_map_start,                                       \
 
88
           (map)->l_map_end - (map)->l_map_start)
 
89
#endif
 
90
 
 
91
/* By default we do not need special support to initialize DSOs loaded
 
92
   by statically linked binaries.  */
 
93
#ifndef DL_STATIC_INIT
 
94
# define DL_STATIC_INIT(map)
 
95
#endif
 
96
 
 
97
/* Reloc type classes as returned by elf_machine_type_class().
 
98
   ELF_RTYPE_CLASS_PLT means this reloc should not be satisfied by
 
99
   some PLT symbol, ELF_RTYPE_CLASS_COPY means this reloc should not be
 
100
   satisfied by any symbol in the executable.  Some architectures do
 
101
   not support copy relocations.  In this case we define the macro to
 
102
   zero so that the code for handling them gets automatically optimized
 
103
   out.  */
 
104
#define ELF_RTYPE_CLASS_PLT 1
 
105
#ifndef DL_NO_COPY_RELOCS
 
106
# define ELF_RTYPE_CLASS_COPY 2
 
107
#else
 
108
# define ELF_RTYPE_CLASS_COPY 0
 
109
#endif
 
110
 
 
111
/* ELF uses the PF_x macros to specify the segment permissions, mmap
 
112
   uses PROT_xxx.  In most cases the three macros have the values 1, 2,
 
113
   and 3 but not in a matching order.  The following macros allows
 
114
   converting from the PF_x values to PROT_xxx values.  */
 
115
#define PF_TO_PROT \
 
116
  ((PROT_READ << (PF_R * 4))                                                  \
 
117
   | (PROT_WRITE << (PF_W * 4))                                               \
 
118
   | (PROT_EXEC << (PF_X * 4))                                                \
 
119
   | ((PROT_READ | PROT_WRITE) << ((PF_R | PF_W) * 4))                        \
 
120
   | ((PROT_READ | PROT_EXEC) << ((PF_R | PF_X) * 4))                         \
 
121
   | ((PROT_WRITE | PROT_EXEC) << (PF_W | PF_X) * 4)                          \
 
122
   | ((PROT_READ | PROT_WRITE | PROT_EXEC) << ((PF_R | PF_W | PF_X) * 4)))
 
123
 
 
124
 
 
125
/* For the version handling we need an array with only names and their
 
126
   hash values.  */
 
127
struct r_found_version
 
128
  {
 
129
    const char *name;
 
130
    ElfW(Word) hash;
 
131
 
 
132
    int hidden;
 
133
    const char *filename;
 
134
  };
 
135
 
 
136
/* We want to cache information about the searches for shared objects.  */
 
137
 
 
138
enum r_dir_status { unknown, nonexisting, existing };
 
139
 
 
140
struct r_search_path_elem
 
141
  {
 
142
    /* This link is only used in the `all_dirs' member of `r_search_path'.  */
 
143
    struct r_search_path_elem *next;
 
144
 
 
145
    /* Strings saying where the definition came from.  */
 
146
    const char *what;
 
147
    const char *where;
 
148
 
 
149
    /* Basename for this search path element.  The string must end with
 
150
       a slash character.  */
 
151
    const char *dirname;
 
152
    size_t dirnamelen;
 
153
 
 
154
    enum r_dir_status status[0];
 
155
  };
 
156
 
 
157
struct r_strlenpair
 
158
  {
 
159
    const char *str;
 
160
    size_t len;
 
161
  };
 
162
 
 
163
 
 
164
/* A data structure for a simple single linked list of strings.  */
 
165
struct libname_list
 
166
  {
 
167
    const char *name;           /* Name requested (before search).  */
 
168
    struct libname_list *next;  /* Link to next name for this object.  */
 
169
    int dont_free;              /* Flag whether this element should be freed
 
170
                                   if the object is not entirely unloaded.  */
 
171
  };
 
172
 
 
173
 
 
174
/* Bit masks for the objects which valid callers can come from to
 
175
   functions with restricted interface.  */
 
176
enum allowmask
 
177
  {
 
178
    allow_libc = 1,
 
179
    allow_libdl = 2,
 
180
    allow_libpthread = 4,
 
181
    allow_ldso = 8
 
182
  };
 
183
 
 
184
 
 
185
/* Type for list of auditing interfaces.  */
 
186
struct La_i86_regs;
 
187
struct La_i86_retval;
 
188
struct La_x86_64_regs;
 
189
struct La_x86_64_retval;
 
190
struct La_x32_regs;
 
191
struct La_x32_retval;
 
192
struct La_ppc32_regs;
 
193
struct La_ppc32_retval;
 
194
struct La_ppc64_regs;
 
195
struct La_ppc64_retval;
 
196
struct La_sh_regs;
 
197
struct La_sh_retval;
 
198
struct La_s390_32_regs;
 
199
struct La_s390_32_retval;
 
200
struct La_s390_64_regs;
 
201
struct La_s390_64_retval;
 
202
struct La_sparc32_regs;
 
203
struct La_sparc32_retval;
 
204
struct La_sparc64_regs;
 
205
struct La_sparc64_retval;
 
206
 
 
207
struct audit_ifaces
 
208
{
 
209
  void (*activity) (uintptr_t *, unsigned int);
 
210
  char *(*objsearch) (const char *, uintptr_t *, unsigned int);
 
211
  unsigned int (*objopen) (struct link_map *, Lmid_t, uintptr_t *);
 
212
  void (*preinit) (uintptr_t *);
 
213
  union
 
214
  {
 
215
    uintptr_t (*symbind32) (Elf32_Sym *, unsigned int, uintptr_t *,
 
216
                            uintptr_t *, unsigned int *, const char *);
 
217
    uintptr_t (*symbind64) (Elf64_Sym *, unsigned int, uintptr_t *,
 
218
                            uintptr_t *, unsigned int *, const char *);
 
219
  };
 
220
  union
 
221
  {
 
222
    Elf32_Addr (*i86_gnu_pltenter) (Elf32_Sym *, unsigned int, uintptr_t *,
 
223
                                    uintptr_t *, struct La_i86_regs *,
 
224
                                    unsigned int *, const char *name,
 
225
                                    long int *framesizep);
 
226
    Elf64_Addr (*x86_64_gnu_pltenter) (Elf64_Sym *, unsigned int, uintptr_t *,
 
227
                                       uintptr_t *, struct La_x86_64_regs *,
 
228
                                       unsigned int *, const char *name,
 
229
                                       long int *framesizep);
 
230
    Elf32_Addr (*x32_gnu_pltenter) (Elf32_Sym *, unsigned int, uintptr_t *,
 
231
                                    uintptr_t *, struct La_x32_regs *,
 
232
                                    unsigned int *, const char *name,
 
233
                                    long int *framesizep);
 
234
    Elf32_Addr (*ppc32_gnu_pltenter) (Elf32_Sym *, unsigned int, uintptr_t *,
 
235
                                      uintptr_t *, struct La_ppc32_regs *,
 
236
                                      unsigned int *, const char *name,
 
237
                                      long int *framesizep);
 
238
    Elf64_Addr (*ppc64_gnu_pltenter) (Elf64_Sym *, unsigned int, uintptr_t *,
 
239
                                      uintptr_t *, struct La_ppc64_regs *,
 
240
                                      unsigned int *, const char *name,
 
241
                                      long int *framesizep);
 
242
    uintptr_t (*sh_gnu_pltenter) (Elf32_Sym *, unsigned int, uintptr_t *,
 
243
                                  uintptr_t *, const struct La_sh_regs *,
 
244
                                  unsigned int *, const char *name,
 
245
                                  long int *framesizep);
 
246
    Elf32_Addr (*s390_32_gnu_pltenter) (Elf32_Sym *, unsigned int, uintptr_t *,
 
247
                                        uintptr_t *, struct La_s390_32_regs *,
 
248
                                        unsigned int *, const char *name,
 
249
                                        long int *framesizep);
 
250
    Elf64_Addr (*s390_64_gnu_pltenter) (Elf64_Sym *, unsigned int, uintptr_t *,
 
251
                                        uintptr_t *, struct La_s390_64_regs *,
 
252
                                        unsigned int *, const char *name,
 
253
                                        long int *framesizep);
 
254
    Elf32_Addr (*sparc32_gnu_pltenter) (Elf32_Sym *, unsigned int,
 
255
                                        uintptr_t *, uintptr_t *,
 
256
                                        const struct La_sparc32_regs *,
 
257
                                        unsigned int *, const char *name,
 
258
                                        long int *framesizep);
 
259
    Elf64_Addr (*sparc64_gnu_pltenter) (Elf64_Sym *, unsigned int,
 
260
                                        uintptr_t *, uintptr_t *,
 
261
                                        const struct La_sparc64_regs *,
 
262
                                        unsigned int *, const char *name,
 
263
                                        long int *framesizep);
 
264
#ifdef ARCH_PLTENTER_MEMBERS
 
265
    ARCH_PLTENTER_MEMBERS;
 
266
#endif
 
267
  };
 
268
  union
 
269
  {
 
270
    unsigned int (*i86_gnu_pltexit) (Elf32_Sym *, unsigned int, uintptr_t *,
 
271
                                     uintptr_t *, const struct La_i86_regs *,
 
272
                                     struct La_i86_retval *, const char *);
 
273
    unsigned int (*x86_64_gnu_pltexit) (Elf64_Sym *, unsigned int, uintptr_t *,
 
274
                                        uintptr_t *,
 
275
                                        const struct La_x86_64_regs *,
 
276
                                        struct La_x86_64_retval *,
 
277
                                        const char *);
 
278
    unsigned int (*x32_gnu_pltexit) (Elf32_Sym *, unsigned int, uintptr_t *,
 
279
                                     uintptr_t *,
 
280
                                     const struct La_x32_regs *,
 
281
                                     struct La_x86_64_retval *,
 
282
                                     const char *);
 
283
    unsigned int (*ppc32_gnu_pltexit) (Elf32_Sym *, unsigned int, uintptr_t *,
 
284
                                       uintptr_t *,
 
285
                                       const struct La_ppc32_regs *,
 
286
                                       struct La_ppc32_retval *, const char *);
 
287
    unsigned int (*ppc64_gnu_pltexit) (Elf64_Sym *, unsigned int, uintptr_t *,
 
288
                                       uintptr_t *,
 
289
                                       const struct La_ppc64_regs *,
 
290
                                       struct La_ppc64_retval *, const char *);
 
291
    unsigned int (*sh_gnu_pltexit) (Elf32_Sym *, unsigned int, uintptr_t *,
 
292
                                    uintptr_t *, const struct La_sh_regs *,
 
293
                                    struct La_sh_retval *, const char *);
 
294
    unsigned int (*s390_32_gnu_pltexit) (Elf32_Sym *, unsigned int,
 
295
                                         uintptr_t *, uintptr_t *,
 
296
                                         const struct La_s390_32_regs *,
 
297
                                         struct La_s390_32_retval *,
 
298
                                         const char *);
 
299
    unsigned int (*s390_64_gnu_pltexit) (Elf64_Sym *, unsigned int,
 
300
                                         uintptr_t *, uintptr_t *,
 
301
                                         const struct La_s390_64_regs *,
 
302
                                         struct La_s390_64_retval *,
 
303
                                         const char *);
 
304
    unsigned int (*sparc32_gnu_pltexit) (Elf32_Sym *, unsigned int,
 
305
                                         uintptr_t *, uintptr_t *,
 
306
                                         const struct La_sparc32_regs *,
 
307
                                         struct La_sparc32_retval *,
 
308
                                         const char *);
 
309
    unsigned int (*sparc64_gnu_pltexit) (Elf64_Sym *, unsigned int,
 
310
                                         uintptr_t *, uintptr_t *,
 
311
                                         const struct La_sparc32_regs *,
 
312
                                         struct La_sparc32_retval *,
 
313
                                         const char *);
 
314
#ifdef ARCH_PLTEXIT_MEMBERS
 
315
    ARCH_PLTEXIT_MEMBERS;
 
316
#endif
 
317
  };
 
318
  unsigned int (*objclose) (uintptr_t *);
 
319
 
 
320
  struct audit_ifaces *next;
 
321
};
 
322
 
 
323
 
 
324
/* Test whether given NAME matches any of the names of the given object.  */
 
325
extern int _dl_name_match_p (const char *__name, const struct link_map *__map)
 
326
     internal_function;
 
327
 
 
328
/* Compute next higher prime number.  */
 
329
extern unsigned long int _dl_higher_prime_number (unsigned long int n)
 
330
     internal_function;
 
331
 
 
332
/* Function used as argument for `_dl_receive_error' function.  The
 
333
   arguments are the error code, error string, and the objname the
 
334
   error occurred in.  */
 
335
typedef void (*receiver_fct) (int, const char *, const char *);
 
336
 
 
337
/* Internal functions of the run-time dynamic linker.
 
338
   These can be accessed if you link again the dynamic linker
 
339
   as a shared library, as in `-lld' or `/lib/ld.so' explicitly;
 
340
   but are not normally of interest to user programs.
 
341
 
 
342
   The `-ldl' library functions in <dlfcn.h> provide a simple
 
343
   user interface to run-time dynamic linking.  */
 
344
 
 
345
 
 
346
#ifndef SHARED
 
347
# define EXTERN extern
 
348
# define GL(name) _##name
 
349
#else
 
350
# define EXTERN
 
351
# ifdef IS_IN_rtld
 
352
#  define GL(name) _rtld_local._##name
 
353
# else
 
354
#  define GL(name) _rtld_global._##name
 
355
# endif
 
356
struct rtld_global
 
357
{
 
358
#endif
 
359
  /* Don't change the order of the following elements.  'dl_loaded'
 
360
     must remain the first element.  Forever.  */
 
361
 
 
362
/* Non-shared code has no support for multiple namespaces.  */
 
363
#ifdef SHARED
 
364
# define DL_NNS 16
 
365
#else
 
366
# define DL_NNS 1
 
367
#endif
 
368
  EXTERN struct link_namespaces
 
369
  {
 
370
    /* A pointer to the map for the main map.  */
 
371
    struct link_map *_ns_loaded;
 
372
    /* Number of object in the _dl_loaded list.  */
 
373
    unsigned int _ns_nloaded;
 
374
    /* Direct pointer to the searchlist of the main object.  */
 
375
    struct r_scope_elem *_ns_main_searchlist;
 
376
    /* This is zero at program start to signal that the global scope map is
 
377
       allocated by rtld.  Later it keeps the size of the map.  It might be
 
378
       reset if in _dl_close if the last global object is removed.  */
 
379
    size_t _ns_global_scope_alloc;
 
380
    /* Search table for unique objects.  */
 
381
    struct unique_sym_table
 
382
    {
 
383
      __rtld_lock_recursive_t lock;
 
384
      struct unique_sym
 
385
      {
 
386
        uint32_t hashval;
 
387
        const char *name;
 
388
        const ElfW(Sym) *sym;
 
389
        const struct link_map *map;
 
390
      } *entries;
 
391
      size_t size;
 
392
      size_t n_elements;
 
393
      void (*free) (void *);
 
394
    } _ns_unique_sym_table;
 
395
    /* Keep track of changes to each namespace' list.  */
 
396
    struct r_debug _ns_debug;
 
397
  } _dl_ns[DL_NNS];
 
398
  /* One higher than index of last used namespace.  */
 
399
  EXTERN size_t _dl_nns;
 
400
 
 
401
  /* During the program run we must not modify the global data of
 
402
     loaded shared object simultanously in two threads.  Therefore we
 
403
     protect `_dl_open' and `_dl_close' in dl-close.c.
 
404
 
 
405
     This must be a recursive lock since the initializer function of
 
406
     the loaded object might as well require a call to this function.
 
407
     At this time it is not anymore a problem to modify the tables.  */
 
408
  __rtld_lock_define_recursive (EXTERN, _dl_load_lock)
 
409
  /* This lock is used to keep __dl_iterate_phdr from inspecting the
 
410
     list of loaded objects while an object is added to or removed
 
411
     from that list.  */
 
412
  __rtld_lock_define_recursive (EXTERN, _dl_load_write_lock)
 
413
 
 
414
  /* Incremented whenever something may have been added to dl_loaded.  */
 
415
  EXTERN unsigned long long _dl_load_adds;
 
416
 
 
417
  /* The object to be initialized first.  */
 
418
  EXTERN struct link_map *_dl_initfirst;
 
419
 
 
420
#if HP_TIMING_AVAIL || HP_SMALL_TIMING_AVAIL
 
421
  /* Start time on CPU clock.  */
 
422
  EXTERN hp_timing_t _dl_cpuclock_offset;
 
423
#endif
 
424
 
 
425
  /* Map of shared object to be profiled.  */
 
426
  EXTERN struct link_map *_dl_profile_map;
 
427
 
 
428
  /* Counters for the number of relocations performed.  */
 
429
  EXTERN unsigned long int _dl_num_relocations;
 
430
  EXTERN unsigned long int _dl_num_cache_relocations;
 
431
 
 
432
  /* List of search directories.  */
 
433
  EXTERN struct r_search_path_elem *_dl_all_dirs;
 
434
 
 
435
#ifdef _LIBC_REENTRANT
 
436
  EXTERN void **(*_dl_error_catch_tsd) (void) __attribute__ ((const));
 
437
#endif
 
438
 
 
439
  /* Structure describing the dynamic linker itself.  We need to
 
440
     reserve memory for the data the audit libraries need.  */
 
441
  EXTERN struct link_map _dl_rtld_map;
 
442
#ifdef SHARED
 
443
  struct auditstate audit_data[DL_NNS];
 
444
#endif
 
445
 
 
446
#if defined SHARED && defined _LIBC_REENTRANT \
 
447
    && defined __rtld_lock_default_lock_recursive
 
448
  EXTERN void (*_dl_rtld_lock_recursive) (void *);
 
449
  EXTERN void (*_dl_rtld_unlock_recursive) (void *);
 
450
#endif
 
451
 
 
452
  /* If loading a shared object requires that we make the stack executable
 
453
     when it was not, we do it by calling this function.
 
454
     It returns an errno code or zero on success.  */
 
455
  EXTERN int (*_dl_make_stack_executable_hook) (void **) internal_function;
 
456
 
 
457
  /* Prevailing state of the stack, PF_X indicating it's executable.  */
 
458
  EXTERN ElfW(Word) _dl_stack_flags;
 
459
 
 
460
  /* Flag signalling whether there are gaps in the module ID allocation.  */
 
461
  EXTERN bool _dl_tls_dtv_gaps;
 
462
  /* Highest dtv index currently needed.  */
 
463
  EXTERN size_t _dl_tls_max_dtv_idx;
 
464
  /* Information about the dtv slots.  */
 
465
  EXTERN struct dtv_slotinfo_list
 
466
  {
 
467
    size_t len;
 
468
    struct dtv_slotinfo_list *next;
 
469
    struct dtv_slotinfo
 
470
    {
 
471
      size_t gen;
 
472
      struct link_map *map;
 
473
    } slotinfo[0];
 
474
  } *_dl_tls_dtv_slotinfo_list;
 
475
  /* Number of modules in the static TLS block.  */
 
476
  EXTERN size_t _dl_tls_static_nelem;
 
477
  /* Size of the static TLS block.  */
 
478
  EXTERN size_t _dl_tls_static_size;
 
479
  /* Size actually allocated in the static TLS block.  */
 
480
  EXTERN size_t _dl_tls_static_used;
 
481
  /* Alignment requirement of the static TLS block.  */
 
482
  EXTERN size_t _dl_tls_static_align;
 
483
 
 
484
/* Number of additional entries in the slotinfo array of each slotinfo
 
485
   list element.  A large number makes it almost certain take we never
 
486
   have to iterate beyond the first element in the slotinfo list.  */
 
487
#define TLS_SLOTINFO_SURPLUS (62)
 
488
 
 
489
/* Number of additional slots in the dtv allocated.  */
 
490
#define DTV_SURPLUS     (14)
 
491
 
 
492
  /* Initial dtv of the main thread, not allocated with normal malloc.  */
 
493
  EXTERN void *_dl_initial_dtv;
 
494
  /* Generation counter for the dtv.  */
 
495
  EXTERN size_t _dl_tls_generation;
 
496
 
 
497
  EXTERN void (*_dl_init_static_tls) (struct link_map *);
 
498
 
 
499
  EXTERN void (*_dl_wait_lookup_done) (void);
 
500
 
 
501
  /* Scopes to free after next THREAD_GSCOPE_WAIT ().  */
 
502
  EXTERN struct dl_scope_free_list
 
503
  {
 
504
    size_t count;
 
505
    void *list[50];
 
506
  } *_dl_scope_free_list;
 
507
#ifdef SHARED
 
508
};
 
509
# define __rtld_global_attribute__
 
510
# ifdef IS_IN_rtld
 
511
#  ifdef HAVE_SDATA_SECTION
 
512
#   define __rtld_local_attribute__ \
 
513
            __attribute__ ((visibility ("hidden"), section (".sdata")))
 
514
#   undef __rtld_global_attribute__
 
515
#   define __rtld_global_attribute__ __attribute__ ((section (".sdata")))
 
516
#  else
 
517
#   define __rtld_local_attribute__ __attribute__ ((visibility ("hidden")))
 
518
#  endif
 
519
extern struct rtld_global _rtld_local __rtld_local_attribute__;
 
520
#  undef __rtld_local_attribute__
 
521
# endif
 
522
extern struct rtld_global _rtld_global __rtld_global_attribute__;
 
523
# undef __rtld_global_attribute__
 
524
#endif
 
525
 
 
526
#if __OPTION_EGLIBC_RTLD_DEBUG
 
527
# define GLRO_dl_debug_mask GLRO(dl_debug_mask)
 
528
#else
 
529
# define GLRO_dl_debug_mask 0
 
530
#endif
 
531
 
 
532
#ifndef SHARED
 
533
# define GLRO(name) _##name
 
534
#else
 
535
# ifdef IS_IN_rtld
 
536
#  define GLRO(name) _rtld_local_ro._##name
 
537
# else
 
538
#  define GLRO(name) _rtld_global_ro._##name
 
539
# endif
 
540
struct rtld_global_ro
 
541
{
 
542
#endif
 
543
 
 
544
#if __OPTION_EGLIBC_RTLD_DEBUG
 
545
  /* If nonzero the appropriate debug information is printed.  */
 
546
  EXTERN int _dl_debug_mask;
 
547
#endif
 
548
#define DL_DEBUG_LIBS       (1 << 0)
 
549
#define DL_DEBUG_IMPCALLS   (1 << 1)
 
550
#define DL_DEBUG_BINDINGS   (1 << 2)
 
551
#define DL_DEBUG_SYMBOLS    (1 << 3)
 
552
#define DL_DEBUG_VERSIONS   (1 << 4)
 
553
#define DL_DEBUG_RELOC      (1 << 5)
 
554
#define DL_DEBUG_FILES      (1 << 6)
 
555
#define DL_DEBUG_STATISTICS (1 << 7)
 
556
#define DL_DEBUG_UNUSED     (1 << 8)
 
557
#define DL_DEBUG_SCOPES     (1 << 9)
 
558
/* These two are used only internally.  */
 
559
#define DL_DEBUG_HELP       (1 << 10)
 
560
#define DL_DEBUG_PRELINK    (1 << 11)
 
561
 
 
562
  /* OS version.  */
 
563
  EXTERN unsigned int _dl_osversion;
 
564
  /* Platform name.  */
 
565
  EXTERN const char *_dl_platform;
 
566
  EXTERN size_t _dl_platformlen;
 
567
 
 
568
  /* Cached value of `getpagesize ()'.  */
 
569
  EXTERN size_t _dl_pagesize;
 
570
 
 
571
  /* Do we read from ld.so.cache?  */
 
572
  EXTERN int _dl_inhibit_cache;
 
573
 
 
574
  /* Copy of the content of `_dl_main_searchlist' at startup time.  */
 
575
  EXTERN struct r_scope_elem _dl_initial_searchlist;
 
576
 
 
577
  /* CLK_TCK as reported by the kernel.  */
 
578
  EXTERN int _dl_clktck;
 
579
 
 
580
  /* If nonzero print warnings messages.  */
 
581
  EXTERN int _dl_verbose;
 
582
 
 
583
  /* File descriptor to write debug messages to.  */
 
584
  EXTERN int _dl_debug_fd;
 
585
 
 
586
  /* Do we do lazy relocations?  */
 
587
  EXTERN int _dl_lazy;
 
588
 
 
589
  /* Nonzero if runtime lookups should not update the .got/.plt.  */
 
590
  EXTERN int _dl_bind_not;
 
591
 
 
592
  /* Nonzero if references should be treated as weak during runtime
 
593
     linking.  */
 
594
  EXTERN int _dl_dynamic_weak;
 
595
 
 
596
  /* Default floating-point control word.  */
 
597
  EXTERN fpu_control_t _dl_fpu_control;
 
598
 
 
599
  /* Expected cache ID.  */
 
600
  EXTERN int _dl_correct_cache_id;
 
601
 
 
602
  /* Mask for hardware capabilities that are available.  */
 
603
  EXTERN uint64_t _dl_hwcap;
 
604
 
 
605
  /* Mask for important hardware capabilities we honour. */
 
606
  EXTERN uint64_t _dl_hwcap_mask;
 
607
 
 
608
  /* Pointer to the auxv list supplied to the program at startup.  */
 
609
  EXTERN ElfW(auxv_t) *_dl_auxv;
 
610
 
 
611
  /* Get architecture specific definitions.  */
 
612
#define PROCINFO_DECL
 
613
#ifndef PROCINFO_CLASS
 
614
# define PROCINFO_CLASS EXTERN
 
615
#endif
 
616
#include <dl-procinfo.c>
 
617
 
 
618
  /* Names of shared object for which the RPATH should be ignored.  */
 
619
  EXTERN const char *_dl_inhibit_rpath;
 
620
 
 
621
  /* Location of the binary.  */
 
622
  EXTERN const char *_dl_origin_path;
 
623
 
 
624
  /* -1 if the dynamic linker should honor library load bias,
 
625
     0 if not, -2 use the default (honor biases for normal
 
626
     binaries, don't honor for PIEs).  */
 
627
  EXTERN ElfW(Addr) _dl_use_load_bias;
 
628
 
 
629
  /* Name of the shared object to be profiled (if any).  */
 
630
  EXTERN const char *_dl_profile;
 
631
  /* Filename of the output file.  */
 
632
  EXTERN const char *_dl_profile_output;
 
633
  /* Name of the object we want to trace the prelinking.  */
 
634
  EXTERN const char *_dl_trace_prelink;
 
635
  /* Map of shared object to be prelink traced.  */
 
636
  EXTERN struct link_map *_dl_trace_prelink_map;
 
637
 
 
638
  /* All search directories defined at startup.  */
 
639
  EXTERN struct r_search_path_elem *_dl_init_all_dirs;
 
640
 
 
641
#if HP_TIMING_AVAIL || HP_SMALL_TIMING_AVAIL
 
642
  /* Overhead of a high-precision timing measurement.  */
 
643
  EXTERN hp_timing_t _dl_hp_timing_overhead;
 
644
#endif
 
645
 
 
646
#ifdef NEED_DL_SYSINFO
 
647
  /* Syscall handling improvements.  This is very specific to x86.  */
 
648
  EXTERN uintptr_t _dl_sysinfo;
 
649
#endif
 
650
 
 
651
#if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
 
652
  /* The vsyscall page is a virtual DSO pre-mapped by the kernel.
 
653
     This points to its ELF header.  */
 
654
  EXTERN const ElfW(Ehdr) *_dl_sysinfo_dso;
 
655
 
 
656
  /* At startup time we set up the normal DSO data structure for it,
 
657
     and this points to it.  */
 
658
  EXTERN struct link_map *_dl_sysinfo_map;
 
659
#endif
 
660
 
 
661
#ifdef SHARED
 
662
  /* We add a function table to _rtld_global which is then used to
 
663
     call the function instead of going through the PLT.  The result
 
664
     is that we can avoid exporting the functions and we do not jump
 
665
     PLT relocations in libc.so.  */
 
666
  void (*_dl_debug_printf) (const char *, ...)
 
667
       __attribute__ ((__format__ (__printf__, 1, 2)));
 
668
  int (internal_function *_dl_catch_error) (const char **, const char **,
 
669
                                            bool *, void (*) (void *), void *);
 
670
  void (internal_function *_dl_signal_error) (int, const char *, const char *,
 
671
                                              const char *);
 
672
  void (*_dl_mcount) (ElfW(Addr) frompc, ElfW(Addr) selfpc);
 
673
  lookup_t (internal_function *_dl_lookup_symbol_x) (const char *,
 
674
                                                     struct link_map *,
 
675
                                                     const ElfW(Sym) **,
 
676
                                                     struct r_scope_elem *[],
 
677
                                                     const struct r_found_version *,
 
678
                                                     int, int,
 
679
                                                     struct link_map *);
 
680
  int (*_dl_check_caller) (const void *, enum allowmask);
 
681
  void *(*_dl_open) (const char *file, int mode, const void *caller_dlopen,
 
682
                     Lmid_t nsid, int argc, char *argv[], char *env[]);
 
683
  void (*_dl_close) (void *map);
 
684
  void *(*_dl_tls_get_addr_soft) (struct link_map *);
 
685
#ifdef HAVE_DL_DISCOVER_OSVERSION
 
686
  int (*_dl_discover_osversion) (void);
 
687
#endif
 
688
 
 
689
  /* List of auditing interfaces.  */
 
690
  struct audit_ifaces *_dl_audit;
 
691
  unsigned int _dl_naudit;
 
692
 
 
693
  /* 0 if internal pointer values should not be guarded, 1 if they should.  */
 
694
  EXTERN int _dl_pointer_guard;
 
695
};
 
696
# define __rtld_global_attribute__
 
697
# ifdef IS_IN_rtld
 
698
#  define __rtld_local_attribute__ __attribute__ ((visibility ("hidden")))
 
699
extern struct rtld_global_ro _rtld_local_ro
 
700
    attribute_relro __rtld_local_attribute__;
 
701
extern struct rtld_global_ro _rtld_global_ro
 
702
    attribute_relro __rtld_global_attribute__;
 
703
#  undef __rtld_local_attribute__
 
704
# else
 
705
/* We cheat a bit here.  We declare the variable as as const even
 
706
   though it is at startup.  */
 
707
extern const struct rtld_global_ro _rtld_global_ro
 
708
    attribute_relro __rtld_global_attribute__;
 
709
# endif
 
710
# undef __rtld_global_attribute__
 
711
#endif
 
712
#undef EXTERN
 
713
 
 
714
#ifdef IS_IN_rtld
 
715
/* This is the initial value of GL(dl_error_catch_tsd).
 
716
   A non-TLS libpthread will change it.  */
 
717
extern void **_dl_initial_error_catch_tsd (void) __attribute__ ((const))
 
718
     attribute_hidden;
 
719
#endif
 
720
 
 
721
/* This is the initial value of GL(dl_make_stack_executable_hook).
 
722
   A threads library can change it.  */
 
723
extern int _dl_make_stack_executable (void **stack_endp) internal_function;
 
724
rtld_hidden_proto (_dl_make_stack_executable)
 
725
 
 
726
/* Variable pointing to the end of the stack (or close to it).  This value
 
727
   must be constant over the runtime of the application.  Some programs
 
728
   might use the variable which results in copy relocations on some
 
729
   platforms.  But this does not matter, ld.so can always use the local
 
730
   copy.  */
 
731
extern void *__libc_stack_end
 
732
#ifndef LIBC_STACK_END_NOT_RELRO
 
733
     attribute_relro
 
734
#endif
 
735
     ;
 
736
rtld_hidden_proto (__libc_stack_end)
 
737
 
 
738
/* Parameters passed to the dynamic linker.  */
 
739
extern int _dl_argc attribute_hidden attribute_relro;
 
740
extern char **_dl_argv
 
741
#ifndef DL_ARGV_NOT_RELRO
 
742
     attribute_relro
 
743
#endif
 
744
     ;
 
745
#ifdef IS_IN_rtld
 
746
extern char **_dl_argv_internal attribute_hidden
 
747
# ifndef DL_ARGV_NOT_RELRO
 
748
     attribute_relro
 
749
# endif
 
750
     ;
 
751
# define rtld_progname (INTUSE(_dl_argv)[0])
 
752
#else
 
753
# define rtld_progname _dl_argv[0]
 
754
#endif
 
755
 
 
756
/* Flag set at startup and cleared when the last initializer has run.  */
 
757
extern int _dl_starting_up;
 
758
weak_extern (_dl_starting_up)
 
759
#ifdef IS_IN_rtld
 
760
extern int _dl_starting_up_internal attribute_hidden;
 
761
#endif
 
762
 
 
763
/* Random data provided by the kernel.  */
 
764
extern void *_dl_random attribute_hidden attribute_relro;
 
765
 
 
766
/* OS-dependent function to open the zero-fill device.  */
 
767
extern int _dl_sysdep_open_zero_fill (void); /* dl-sysdep.c */
 
768
 
 
769
 
 
770
/* Write message on the debug file descriptor.  The parameters are
 
771
   interpreted as for a `printf' call.  All the lines start with a
 
772
   tag showing the PID.  */
 
773
extern void _dl_debug_printf (const char *fmt, ...)
 
774
     __attribute__ ((__format__ (__printf__, 1, 2))) attribute_hidden;
 
775
 
 
776
/* Write message on the debug file descriptor.  The parameters are
 
777
   interpreted as for a `printf' call.  All the lines buf the first
 
778
   start with a tag showing the PID.  */
 
779
extern void _dl_debug_printf_c (const char *fmt, ...)
 
780
     __attribute__ ((__format__ (__printf__, 1, 2)));
 
781
 
 
782
 
 
783
/* Write a message on the specified descriptor FD.  The parameters are
 
784
   interpreted as for a `printf' call.  */
 
785
extern void _dl_dprintf (int fd, const char *fmt, ...)
 
786
     __attribute__ ((__format__ (__printf__, 2, 3)))
 
787
     attribute_hidden;
 
788
 
 
789
/* Write a message on the specified descriptor standard output.  The
 
790
   parameters are interpreted as for a `printf' call.  */
 
791
#define _dl_printf(fmt, args...) \
 
792
  _dl_dprintf (STDOUT_FILENO, fmt, ##args)
 
793
 
 
794
/* Write a message on the specified descriptor standard error.  The
 
795
   parameters are interpreted as for a `printf' call.  */
 
796
#define _dl_error_printf(fmt, args...) \
 
797
  _dl_dprintf (STDERR_FILENO, fmt, ##args)
 
798
 
 
799
/* Write a message on the specified descriptor standard error and exit
 
800
   the program.  The parameters are interpreted as for a `printf' call.  */
 
801
#define _dl_fatal_printf(fmt, args...) \
 
802
  do                                                                          \
 
803
    {                                                                         \
 
804
      _dl_dprintf (STDERR_FILENO, fmt, ##args);                               \
 
805
      _exit (127);                                                            \
 
806
    }                                                                         \
 
807
  while (1)
 
808
 
 
809
 
 
810
/* This function is called by all the internal dynamic linker functions
 
811
   when they encounter an error.  ERRCODE is either an `errno' code or
 
812
   zero; OBJECT is the name of the problematical shared object, or null if
 
813
   it is a general problem; ERRSTRING is a string describing the specific
 
814
   problem.  */
 
815
extern void _dl_signal_error (int errcode, const char *object,
 
816
                              const char *occurred, const char *errstring)
 
817
     internal_function __attribute__ ((__noreturn__)) attribute_hidden;
 
818
 
 
819
/* Like _dl_signal_error, but may return when called in the context of
 
820
   _dl_receive_error.  */
 
821
extern void _dl_signal_cerror (int errcode, const char *object,
 
822
                               const char *occation, const char *errstring)
 
823
     internal_function;
 
824
 
 
825
/* Call OPERATE, receiving errors from `dl_signal_cerror'.  Unlike
 
826
   `_dl_catch_error' the operation is resumed after the OPERATE
 
827
   function returns.
 
828
   ARGS is passed as argument to OPERATE.  */
 
829
extern void _dl_receive_error (receiver_fct fct, void (*operate) (void *),
 
830
                               void *args)
 
831
     internal_function;
 
832
 
 
833
 
 
834
/* Open the shared object NAME and map in its segments.
 
835
   LOADER's DT_RPATH is used in searching for NAME.
 
836
   If the object is already opened, returns its existing map.  */
 
837
extern struct link_map *_dl_map_object (struct link_map *loader,
 
838
                                        const char *name,
 
839
                                        int type, int trace_mode, int mode,
 
840
                                        Lmid_t nsid)
 
841
     internal_function attribute_hidden;
 
842
 
 
843
/* Call _dl_map_object on the dependencies of MAP, and set up
 
844
   MAP->l_searchlist.  PRELOADS points to a vector of NPRELOADS previously
 
845
   loaded objects that will be inserted into MAP->l_searchlist after MAP
 
846
   but before its dependencies.  */
 
847
extern void _dl_map_object_deps (struct link_map *map,
 
848
                                 struct link_map **preloads,
 
849
                                 unsigned int npreloads, int trace_mode,
 
850
                                 int open_mode)
 
851
     internal_function attribute_hidden;
 
852
 
 
853
/* Cache the locations of MAP's hash table.  */
 
854
extern void _dl_setup_hash (struct link_map *map)
 
855
     internal_function attribute_hidden;
 
856
 
 
857
 
 
858
/* Collect the directories in the search path for LOADER's dependencies.
 
859
   The data structure is defined in <dlfcn.h>.  If COUNTING is true,
 
860
   SI->dls_cnt and SI->dls_size are set; if false, those must be as set
 
861
   by a previous call with COUNTING set, and SI must point to SI->dls_size
 
862
   bytes to be used in filling in the result.  */
 
863
extern void _dl_rtld_di_serinfo (struct link_map *loader,
 
864
                                 Dl_serinfo *si, bool counting)
 
865
     internal_function;
 
866
 
 
867
 
 
868
/* Search loaded objects' symbol tables for a definition of the symbol
 
869
   referred to by UNDEF.  *SYM is the symbol table entry containing the
 
870
   reference; it is replaced with the defining symbol, and the base load
 
871
   address of the defining object is returned.  SYMBOL_SCOPE is a
 
872
   null-terminated list of object scopes to search; each object's
 
873
   l_searchlist (i.e. the segment of the dependency tree starting at that
 
874
   object) is searched in turn.  REFERENCE_NAME should name the object
 
875
   containing the reference; it is used in error messages.
 
876
   TYPE_CLASS describes the type of symbol we are looking for.  */
 
877
enum
 
878
  {
 
879
    /* If necessary add dependency between user and provider object.  */
 
880
    DL_LOOKUP_ADD_DEPENDENCY = 1,
 
881
    /* Return most recent version instead of default version for
 
882
       unversioned lookup.  */
 
883
    DL_LOOKUP_RETURN_NEWEST = 2,
 
884
    /* Set if dl_lookup* called with GSCOPE lock held.  */
 
885
    DL_LOOKUP_GSCOPE_LOCK = 4,
 
886
  };
 
887
 
 
888
/* Lookup versioned symbol.  */
 
889
extern lookup_t _dl_lookup_symbol_x (const char *undef,
 
890
                                     struct link_map *undef_map,
 
891
                                     const ElfW(Sym) **sym,
 
892
                                     struct r_scope_elem *symbol_scope[],
 
893
                                     const struct r_found_version *version,
 
894
                                     int type_class, int flags,
 
895
                                     struct link_map *skip_map)
 
896
     internal_function attribute_hidden;
 
897
 
 
898
 
 
899
/* Look up symbol NAME in MAP's scope and return its run-time address.  */
 
900
extern ElfW(Addr) _dl_symbol_value (struct link_map *map, const char *name)
 
901
     internal_function;
 
902
 
 
903
/* Add the new link_map NEW to the end of the namespace list.  */
 
904
extern void _dl_add_to_namespace_list (struct link_map *new, Lmid_t nsid)
 
905
     internal_function attribute_hidden;
 
906
 
 
907
/* Allocate a `struct link_map' for a new object being loaded.  */
 
908
extern struct link_map *_dl_new_object (char *realname, const char *libname,
 
909
                                        int type, struct link_map *loader,
 
910
                                        int mode, Lmid_t nsid)
 
911
     internal_function attribute_hidden;
 
912
 
 
913
/* Relocate the given object (if it hasn't already been).
 
914
   SCOPE is passed to _dl_lookup_symbol in symbol lookups.
 
915
   If RTLD_LAZY is set in RELOC-MODE, don't relocate its PLT.  */
 
916
extern void _dl_relocate_object (struct link_map *map,
 
917
                                 struct r_scope_elem *scope[],
 
918
                                 int reloc_mode, int consider_profiling)
 
919
     attribute_hidden;
 
920
 
 
921
/* Protect PT_GNU_RELRO area.  */
 
922
extern void _dl_protect_relro (struct link_map *map)
 
923
     internal_function attribute_hidden;
 
924
 
 
925
/* Call _dl_signal_error with a message about an unhandled reloc type.
 
926
   TYPE is the result of ELFW(R_TYPE) (r_info), i.e. an R_<CPU>_* value.
 
927
   PLT is nonzero if this was a PLT reloc; it just affects the message.  */
 
928
extern void _dl_reloc_bad_type (struct link_map *map,
 
929
                                unsigned int type, int plt)
 
930
     internal_function __attribute__ ((__noreturn__));
 
931
 
 
932
/* Resolve conflicts if prelinking.  */
 
933
extern void _dl_resolve_conflicts (struct link_map *l,
 
934
                                   ElfW(Rela) *conflict,
 
935
                                   ElfW(Rela) *conflictend);
 
936
 
 
937
/* Check the version dependencies of all objects available through
 
938
   MAP.  If VERBOSE print some more diagnostics.  */
 
939
extern int _dl_check_all_versions (struct link_map *map, int verbose,
 
940
                                   int trace_mode)
 
941
     internal_function;
 
942
 
 
943
/* Check the version dependencies for MAP.  If VERBOSE print some more
 
944
   diagnostics.  */
 
945
extern int _dl_check_map_versions (struct link_map *map, int verbose,
 
946
                                   int trace_mode)
 
947
     internal_function;
 
948
 
 
949
/* Initialize the object in SCOPE by calling the constructors with
 
950
   ARGC, ARGV, and ENV as the parameters.  */
 
951
extern void _dl_init (struct link_map *main_map, int argc, char **argv,
 
952
                      char **env) internal_function attribute_hidden;
 
953
 
 
954
/* Call the finalizer functions of all shared objects whose
 
955
   initializer functions have completed.  */
 
956
extern void _dl_fini (void) internal_function;
 
957
 
 
958
/* Sort array MAPS according to dependencies of the contained objects.  */
 
959
extern void _dl_sort_fini (struct link_map **maps, size_t nmaps, char *used,
 
960
                           Lmid_t ns)
 
961
     internal_function;
 
962
 
 
963
/* The dynamic linker calls this function before and having changing
 
964
   any shared object mappings.  The `r_state' member of `struct r_debug'
 
965
   says what change is taking place.  This function's address is
 
966
   the value of the `r_brk' member.  */
 
967
extern void _dl_debug_state (void);
 
968
rtld_hidden_proto (_dl_debug_state)
 
969
 
 
970
/* Initialize `struct r_debug' if it has not already been done.  The
 
971
   argument is the run-time load address of the dynamic linker, to be put
 
972
   in the `r_ldbase' member.  Returns the address of the structure.  */
 
973
extern struct r_debug *_dl_debug_initialize (ElfW(Addr) ldbase, Lmid_t ns)
 
974
     internal_function;
 
975
 
 
976
/* Initialize the basic data structure for the search paths.  */
 
977
extern void _dl_init_paths (const char *library_path) internal_function;
 
978
 
 
979
/* Gather the information needed to install the profiling tables and start
 
980
   the timers.  */
 
981
extern void _dl_start_profile (void) internal_function attribute_hidden;
 
982
 
 
983
/* The actual functions used to keep book on the calls.  */
 
984
extern void _dl_mcount (ElfW(Addr) frompc, ElfW(Addr) selfpc);
 
985
extern void _dl_mcount_internal (ElfW(Addr) frompc, ElfW(Addr) selfpc)
 
986
     attribute_hidden;
 
987
 
 
988
/* This function is simply a wrapper around the _dl_mcount function
 
989
   which does not require a FROMPC parameter since this is the
 
990
   calling function.  */
 
991
extern void _dl_mcount_wrapper (void *selfpc);
 
992
 
 
993
/* Show the members of the auxiliary array passed up from the kernel.  */
 
994
extern void _dl_show_auxv (void) internal_function;
 
995
 
 
996
/* Return all environment variables starting with `LD_', one after the
 
997
   other.  */
 
998
extern char *_dl_next_ld_env_entry (char ***position) internal_function;
 
999
 
 
1000
/* Return an array with the names of the important hardware capabilities.  */
 
1001
extern const struct r_strlenpair *_dl_important_hwcaps (const char *platform,
 
1002
                                                        size_t paltform_len,
 
1003
                                                        size_t *sz,
 
1004
                                                        size_t *max_capstrlen)
 
1005
     internal_function;
 
1006
 
 
1007
/* Look up NAME in ld.so.cache and return the file name stored there,
 
1008
   or null if none is found.  */
 
1009
extern const char *_dl_load_cache_lookup (const char *name)
 
1010
     internal_function;
 
1011
 
 
1012
/* If the system does not support MAP_COPY we cannot leave the file open
 
1013
   all the time since this would create problems when the file is replaced.
 
1014
   Therefore we provide this function to close the file and open it again
 
1015
   once needed.  */
 
1016
extern void _dl_unload_cache (void) attribute_hidden;
 
1017
 
 
1018
/* System-dependent function to read a file's whole contents in the
 
1019
   most convenient manner available.  *SIZEP gets the size of the
 
1020
   file.  On error MAP_FAILED is returned.  */
 
1021
extern void *_dl_sysdep_read_whole_file (const char *file, size_t *sizep,
 
1022
                                         int prot)
 
1023
     internal_function attribute_hidden;
 
1024
 
 
1025
/* System-specific function to do initial startup for the dynamic linker.
 
1026
   After this, file access calls and getenv must work.  This is responsible
 
1027
   for setting __libc_enable_secure if we need to be secure (e.g. setuid),
 
1028
   and for setting _dl_argc and _dl_argv, and then calling _dl_main.  */
 
1029
extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
 
1030
                                    void (*dl_main) (const ElfW(Phdr) *phdr,
 
1031
                                                     ElfW(Word) phnum,
 
1032
                                                     ElfW(Addr) *user_entry,
 
1033
                                                     ElfW(auxv_t) *auxv))
 
1034
     attribute_hidden;
 
1035
 
 
1036
extern void _dl_sysdep_start_cleanup (void)
 
1037
     internal_function attribute_hidden;
 
1038
 
 
1039
 
 
1040
/* Determine next available module ID.  */
 
1041
extern size_t _dl_next_tls_modid (void) internal_function attribute_hidden;
 
1042
 
 
1043
/* Calculate offset of the TLS blocks in the static TLS block.  */
 
1044
extern void _dl_determine_tlsoffset (void) internal_function attribute_hidden;
 
1045
 
 
1046
/* Set up the data structures for TLS, when they were not set up at startup.
 
1047
   Returns nonzero on malloc failure.
 
1048
   This is called from _dl_map_object_from_fd or by libpthread.  */
 
1049
extern int _dl_tls_setup (void) internal_function;
 
1050
rtld_hidden_proto (_dl_tls_setup)
 
1051
 
 
1052
/* Allocate memory for static TLS block (unless MEM is nonzero) and dtv.  */
 
1053
extern void *_dl_allocate_tls (void *mem) internal_function;
 
1054
rtld_hidden_proto (_dl_allocate_tls)
 
1055
 
 
1056
/* Get size and alignment requirements of the static TLS block.  */
 
1057
extern void _dl_get_tls_static_info (size_t *sizep, size_t *alignp)
 
1058
     internal_function;
 
1059
 
 
1060
extern void _dl_allocate_static_tls (struct link_map *map)
 
1061
     internal_function attribute_hidden;
 
1062
 
 
1063
/* These are internal entry points to the two halves of _dl_allocate_tls,
 
1064
   only used within rtld.c itself at startup time.  */
 
1065
extern void *_dl_allocate_tls_storage (void)
 
1066
     internal_function attribute_hidden;
 
1067
extern void *_dl_allocate_tls_init (void *) internal_function;
 
1068
rtld_hidden_proto (_dl_allocate_tls_init)
 
1069
 
 
1070
/* Deallocate memory allocated with _dl_allocate_tls.  */
 
1071
extern void _dl_deallocate_tls (void *tcb, bool dealloc_tcb) internal_function;
 
1072
rtld_hidden_proto (_dl_deallocate_tls)
 
1073
 
 
1074
extern void _dl_nothread_init_static_tls (struct link_map *) attribute_hidden;
 
1075
 
 
1076
/* Find origin of the executable.  */
 
1077
extern const char *_dl_get_origin (void) attribute_hidden;
 
1078
 
 
1079
/* Count DSTs.  */
 
1080
extern size_t _dl_dst_count (const char *name, int is_path) attribute_hidden;
 
1081
 
 
1082
/* Substitute DST values.  */
 
1083
extern char *_dl_dst_substitute (struct link_map *l, const char *name,
 
1084
                                 char *result, int is_path) attribute_hidden;
 
1085
 
 
1086
/* Check validity of the caller.  */
 
1087
extern int _dl_check_caller (const void *caller, enum allowmask mask)
 
1088
     attribute_hidden;
 
1089
 
 
1090
/* Open the shared object NAME, relocate it, and run its initializer if it
 
1091
   hasn't already been run.  MODE is as for `dlopen' (see <dlfcn.h>).  If
 
1092
   the object is already opened, returns its existing map.  */
 
1093
extern void *_dl_open (const char *name, int mode, const void *caller,
 
1094
                       Lmid_t nsid, int argc, char *argv[], char *env[])
 
1095
     attribute_hidden;
 
1096
 
 
1097
/* Free or queue for freeing scope OLD.  If other threads might be
 
1098
   in the middle of _dl_fixup, _dl_profile_fixup or dl*sym using the
 
1099
   old scope, OLD can't be freed until no thread is using it.  */
 
1100
extern int _dl_scope_free (void *) attribute_hidden;
 
1101
 
 
1102
/* Add module to slot information data.  */
 
1103
extern void _dl_add_to_slotinfo (struct link_map  *l) attribute_hidden;
 
1104
 
 
1105
/* Update slot information data for at least the generation of the
 
1106
   module with the given index.  */
 
1107
extern struct link_map *_dl_update_slotinfo (unsigned long int req_modid);
 
1108
 
 
1109
/* Look up the module's TLS block as for __tls_get_addr,
 
1110
   but never touch anything.  Return null if it's not allocated yet.  */
 
1111
extern void *_dl_tls_get_addr_soft (struct link_map *l) attribute_hidden;
 
1112
 
 
1113
extern int _dl_addr_inside_object (struct link_map *l, const ElfW(Addr) addr)
 
1114
     internal_function attribute_hidden;
 
1115
 
 
1116
/* Show show of an object.  */
 
1117
extern void _dl_show_scope (struct link_map *new, int from);
 
1118
 
 
1119
__END_DECLS
 
1120
 
 
1121
#endif /* ldsodefs.h */