elf/dynamic-link.h

   1 /* Inline functions for dynamic linking.
   2    Copyright (C) 1995,96,97,98,99,2000,2001,2002 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 <elf.h>
  21 #include <dl-machine.h>
  22 #include <assert.h>
  23
  24 #ifndef VERSYMIDX
  25 # define VERSYMIDX(sym) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (sym))
  26 #endif
  27
  28
  29 /* Read the dynamic section at DYN and fill in INFO with indices DT_*.  */
  30
  31 static inline void __attribute__ ((unused))
  32 elf_get_dynamic_info (struct link_map *l)
  33 {
  34   ElfW(Dyn) *dyn = l->l_ld;
  35   ElfW(Addr) l_addr;
  36   ElfW(Dyn) **info;
  37
  38   if (! dyn)
  39     return;
  40
  41   l_addr = l->l_addr;
  42   info = l->l_info;
  43
  44   while (dyn->d_tag != DT_NULL)
  45     {
  46       if (dyn->d_tag < DT_NUM)
  47         info[dyn->d_tag] = dyn;
  48       else if (dyn->d_tag >= DT_LOPROC &&
  49                dyn->d_tag < DT_LOPROC + DT_THISPROCNUM)
  50         info[dyn->d_tag - DT_LOPROC + DT_NUM] = dyn;
  51       else if ((Elf32_Word) DT_VERSIONTAGIDX (dyn->d_tag) < DT_VERSIONTAGNUM)
  52         info[VERSYMIDX (dyn->d_tag)] = dyn;
  53       else if ((Elf32_Word) DT_EXTRATAGIDX (dyn->d_tag) < DT_EXTRANUM)
  54         info[DT_EXTRATAGIDX (dyn->d_tag) + DT_NUM + DT_THISPROCNUM
  55              + DT_VERSIONTAGNUM] = dyn;
  56       else if ((Elf32_Word) DT_VALTAGIDX (dyn->d_tag) < DT_VALNUM)
  57         info[DT_VALTAGIDX (dyn->d_tag) + DT_NUM + DT_THISPROCNUM
  58              + DT_VERSIONTAGNUM + DT_EXTRANUM] = dyn;
  59       else if ((Elf32_Word) DT_ADDRTAGIDX (dyn->d_tag) < DT_ADDRNUM)
  60         info[DT_ADDRTAGIDX (dyn->d_tag) + DT_NUM + DT_THISPROCNUM
  61              + DT_VERSIONTAGNUM + DT_EXTRANUM + DT_VALNUM] = dyn;
  62       else
  63         assert (! "bad dynamic tag");
  64       ++dyn;
  65     }
  66 #ifndef DL_RO_DYN_SECTION
  67   /* Don't adjust .dynamic unnecessarily.  */
  68   if (l_addr)
  69     {
  70       if (info[DT_PLTGOT] != NULL)
  71         info[DT_PLTGOT]->d_un.d_ptr += l_addr;
  72       if (info[DT_STRTAB] != NULL)
  73         info[DT_STRTAB]->d_un.d_ptr += l_addr;
  74       if (info[DT_SYMTAB] != NULL)
  75         info[DT_SYMTAB]->d_un.d_ptr += l_addr;
  76 # if ! ELF_MACHINE_NO_RELA
  77       if (info[DT_RELA] != NULL)
  78         info[DT_RELA]->d_un.d_ptr += l_addr;
  79 # endif
  80 # if ! ELF_MACHINE_NO_REL
  81       if (info[DT_REL] != NULL)
  82         info[DT_REL]->d_un.d_ptr += l_addr;
  83 # endif
  84       if (info[DT_JMPREL] != NULL)
  85         info[DT_JMPREL]->d_un.d_ptr += l_addr;
  86       if (info[VERSYMIDX (DT_VERSYM)] != NULL)
  87         info[VERSYMIDX (DT_VERSYM)]->d_un.d_ptr += l_addr;
  88     }
  89 #endif
  90   if (info[DT_PLTREL] != NULL)
  91     {
  92 # if ELF_MACHINE_NO_RELA
  93       assert (info[DT_PLTREL]->d_un.d_val == DT_REL);
  94 # elif ELF_MACHINE_NO_REL
  95       assert (info[DT_PLTREL]->d_un.d_val == DT_RELA);
  96 # else
  97       assert (info[DT_PLTREL]->d_un.d_val == DT_REL
  98               || info[DT_PLTREL]->d_un.d_val == DT_RELA);
  99 # endif
 100     }
 101 # if ! ELF_MACHINE_NO_RELA
 102   if (info[DT_RELA] != NULL)
 103     assert (info[DT_RELAENT]->d_un.d_val == sizeof (ElfW(Rela)));
 104 # endif
 105 # if ! ELF_MACHINE_NO_REL
 106   if (info[DT_REL] != NULL)
 107     assert (info[DT_RELENT]->d_un.d_val == sizeof (ElfW(Rel)));
 108 # endif
 109   if (info[DT_FLAGS] != NULL)
 110     {
 111       /* Flags are used.  Translate to the old form where available.
 112          Since these l_info entries are only tested for NULL pointers it
 113          is ok if they point to the DT_FLAGS entry.  */
 114       ElfW(Word) flags = info[DT_FLAGS]->d_un.d_val;
 115       if (flags & DF_SYMBOLIC)
 116         info[DT_SYMBOLIC] = info[DT_FLAGS];
 117       if (flags & DF_TEXTREL)
 118         info[DT_TEXTREL] = info[DT_FLAGS];
 119       if (flags & DF_BIND_NOW)
 120         info[DT_BIND_NOW] = info[DT_FLAGS];
 121     }
 122   if (info[VERSYMIDX (DT_FLAGS_1)] != NULL)
 123     l->l_flags_1 = info[VERSYMIDX (DT_FLAGS_1)]->d_un.d_val;
 124   if (info[DT_RUNPATH] != NULL)
 125     /* If both RUNPATH and RPATH are given, the latter is ignored.  */
 126     info[DT_RPATH] = NULL;
 127 }
 128
 129 #ifdef RESOLVE
 130
 131 /* Get the definitions of `elf_dynamic_do_rel' and `elf_dynamic_do_rela'.
 132    These functions are almost identical, so we use cpp magic to avoid
 133    duplicating their code.  It cannot be done in a more general function
 134    because we must be able to completely inline.  */
 135
 136 /* On some machines, notably SPARC, DT_REL* includes DT_JMPREL in its
 137    range.  Note that according to the ELF spec, this is completely legal!
 138    But conditionally define things so that on machines we know this will
 139    not happen we do something more optimal.  */
 140
 141 # ifdef ELF_MACHINE_PLTREL_OVERLAP
 142 #  define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, do_lazy, test_rel) \
 143   do {                                                                        \
 144     struct { ElfW(Addr) start, size; int lazy; } ranges[3];                   \
 145     int ranges_index;                                                         \
 146                                                                               \
 147     ranges[0].lazy = ranges[2].lazy = 0;                                      \
 148     ranges[1].lazy = 1;                                                       \
 149     ranges[0].size = ranges[1].size = ranges[2].size = 0;                     \
 150                                                                               \
 151     if ((map)->l_info[DT_##RELOC])                                            \
 152       {                                                                       \
 153         ranges[0].start = D_PTR ((map), l_info[DT_##RELOC]);                  \
 154         ranges[0].size = (map)->l_info[DT_##RELOC##SZ]->d_un.d_val;           \
 155       }                                                                       \
 156                                                                               \
 157      if ((do_lazy)                                                            \
 158         && (map)->l_info[DT_PLTREL]                                           \
 159         && (!test_rel || (map)->l_info[DT_PLTREL]->d_un.d_val == DT_##RELOC)) \
 160       {                                                                       \
 161         ranges[1].start = D_PTR ((map), l_info[DT_JMPREL]);                   \
 162         ranges[1].size = (map)->l_info[DT_PLTRELSZ]->d_un.d_val;              \
 163         ranges[2].start = ranges[1].start + ranges[1].size;                   \
 164         ranges[2].size = ranges[0].start + ranges[0].size - ranges[2].start;  \
 165         ranges[0].size = ranges[1].start - ranges[0].start;                   \
 166       }                                                                       \
 167                                                                               \
 168     for (ranges_index = 0; ranges_index < 3; ++ranges_index)                  \
 169       elf_dynamic_do_##reloc ((map),                                          \
 170                               ranges[ranges_index].start,                     \
 171                               ranges[ranges_index].size,                      \
 172                               ranges[ranges_index].lazy);                     \
 173   } while (0)
 174 # else
 175 #  define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, do_lazy, test_rel) \
 176   do {                                                                        \
 177     struct { ElfW(Addr) start, size; int lazy; } ranges[2];                   \
 178     int ranges_index;                                                         \
 179     ranges[0].lazy = 0;                                                       \
 180     ranges[0].size = ranges[1].size = 0;                                      \
 181     ranges[0].start = 0;                                                      \
 182                                                                               \
 183     if ((map)->l_info[DT_##RELOC])                                            \
 184       {                                                                       \
 185         ranges[0].start = D_PTR ((map), l_info[DT_##RELOC]);                  \
 186         ranges[0].size = (map)->l_info[DT_##RELOC##SZ]->d_un.d_val;           \
 187       }                                                                       \
 188     if ((map)->l_info[DT_PLTREL]                                              \
 189         && (!test_rel || (map)->l_info[DT_PLTREL]->d_un.d_val == DT_##RELOC)) \
 190       {                                                                       \
 191         ElfW(Addr) start = D_PTR ((map), l_info[DT_JMPREL]);                  \
 192                                                                               \
 193         if ((do_lazy)                                                         \
 194             /* This test does not only detect whether the relocation          \
 195                sections are in the right order, it also checks whether        \
 196                there is a DT_REL/DT_RELA section.  */                         \
 197             || ranges[0].start + ranges[0].size != start)                     \
 198           {                                                                   \
 199             ranges[1].start = start;                                          \
 200             ranges[1].size = (map)->l_info[DT_PLTRELSZ]->d_un.d_val;          \
 201             ranges[1].lazy = (do_lazy);                                       \
 202           }                                                                   \
 203         else                                                                  \
 204           /* Combine processing the sections.  */                             \
 205           ranges[0].size += (map)->l_info[DT_PLTRELSZ]->d_un.d_val;           \
 206       }                                                                       \
 207                                                                               \
 208     for (ranges_index = 0; ranges_index < 2; ++ranges_index)                  \
 209       elf_dynamic_do_##reloc ((map),                                          \
 210                               ranges[ranges_index].start,                     \
 211                               ranges[ranges_index].size,                      \
 212                               ranges[ranges_index].lazy);                     \
 213   } while (0)
 214 # endif
 215
 216 # if ELF_MACHINE_NO_REL || ELF_MACHINE_NO_RELA
 217 #  define _ELF_CHECK_REL 0
 218 # else
 219 #  define _ELF_CHECK_REL 1
 220 # endif
 221
 222 # if ! ELF_MACHINE_NO_REL
 223 #  include "do-rel.h"
 224 #  define ELF_DYNAMIC_DO_REL(map, lazy) \
 225   _ELF_DYNAMIC_DO_RELOC (REL, rel, map, lazy, _ELF_CHECK_REL)
 226 # else
 227 #  define ELF_DYNAMIC_DO_REL(map, lazy) /* Nothing to do.  */
 228 # endif
 229
 230 # if ! ELF_MACHINE_NO_RELA
 231 #  define DO_RELA
 232 #  include "do-rel.h"
 233 #  define ELF_DYNAMIC_DO_RELA(map, lazy) \
 234   _ELF_DYNAMIC_DO_RELOC (RELA, rela, map, lazy, _ELF_CHECK_REL)
 235 # else
 236 #  define ELF_DYNAMIC_DO_RELA(map, lazy) /* Nothing to do.  */
 237 # endif
 238
 239 /* This can't just be an inline function because GCC is too dumb
 240    to inline functions containing inlines themselves.  */
 241 # define ELF_DYNAMIC_RELOCATE(map, lazy, consider_profile) \
 242   do {                                                                        \
 243     int edr_lazy = elf_machine_runtime_setup ((map), (lazy),                  \
 244                                               (consider_profile));            \
 245     ELF_DYNAMIC_DO_REL ((map), edr_lazy);                                     \
 246     ELF_DYNAMIC_DO_RELA ((map), edr_lazy);                                    \
 247   } while (0)
 248
 249 #endif