bfd/elf-vxworks.c

   1 /* VxWorks support for ELF
   2    Copyright 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19    MA 02111-1307, USA.  */
  20
  21 /* This file provides routines used by all VxWorks targets.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf-vxworks.h"
  28 #include "elf/vxworks.h"
  29
  30 /* Return true if symbol NAME, as defined by ABFD, is one of the special
  31    __GOTT_BASE__ or __GOTT_INDEX__ symbols.  */
  32
  33 static bfd_boolean
  34 elf_vxworks_gott_symbol_p (bfd *abfd, const char *name)
  35 {
  36   char leading;
  37
  38   leading = bfd_get_symbol_leading_char (abfd);
  39   if (leading)
  40     {
  41       if (*name != leading)
  42         return FALSE;
  43       name++;
  44     }
  45   return (strcmp (name, "__GOTT_BASE__") == 0
  46           || strcmp (name, "__GOTT_INDEX__") == 0);
  47 }
  48
  49 /* Tweak magic VxWorks symbols as they are loaded.  */
  50 bfd_boolean
  51 elf_vxworks_add_symbol_hook (bfd *abfd,
  52                              struct bfd_link_info *info,
  53                              Elf_Internal_Sym *sym,
  54                              const char **namep,
  55                              flagword *flagsp,
  56                              asection **secp ATTRIBUTE_UNUSED,
  57                              bfd_vma *valp ATTRIBUTE_UNUSED)
  58 {
  59   /* Ideally these "magic" symbols would be exported by libc.so.1
  60      which would be found via a DT_NEEDED tag, and then handled
  61      specially by the linker at runtime.  Except shared libraries
  62      don't even link to libc.so.1 by default...
  63      If the symbol is imported from, or will be put in a shared library,
  64      give the symbol weak binding to get the desired samantics.
  65      This transformation will be undone in
  66      elf_i386_vxworks_link_output_symbol_hook. */
  67   if ((info->shared || abfd->flags & DYNAMIC)
  68       && elf_vxworks_gott_symbol_p (abfd, *namep))
  69     {
  70       sym->st_info = ELF_ST_INFO (STB_WEAK, ELF_ST_TYPE (sym->st_info));
  71       *flagsp |= BSF_WEAK;
  72     }
  73
  74   return TRUE;
  75 }
  76
  77 /* Perform VxWorks-specific handling of the create_dynamic_sections hook.
  78    When creating an executable, set *SRELPLT2_OUT to the .rel(a).plt.unloaded
  79    section.  */
  80
  81 bfd_boolean
  82 elf_vxworks_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info,
  83                                      asection **srelplt2_out)
  84 {
  85   struct elf_link_hash_table *htab;
  86   const struct elf_backend_data *bed;
  87   asection *s;
  88
  89   htab = elf_hash_table (info);
  90   bed = get_elf_backend_data (dynobj);
  91
  92   if (!info->shared)
  93     {
  94       s = bfd_make_section_anyway_with_flags (dynobj,
  95                                               bed->default_use_rela_p
  96                                               ? ".rela.plt.unloaded"
  97                                               : ".rel.plt.unloaded",
  98                                               SEC_HAS_CONTENTS | SEC_IN_MEMORY
  99                                               | SEC_READONLY
 100                                               | SEC_LINKER_CREATED);
 101       if (s == NULL
 102           || !bfd_set_section_alignment (dynobj, s, bed->s->log_file_align))
 103         return FALSE;
 104
 105       *srelplt2_out = s;
 106     }
 107
 108   /* Mark the GOT and PLT symbols as having relocations; they might
 109      not, but we won't know for sure until we build the GOT in
 110      finish_dynamic_symbol.  Also make sure that the GOT symbol
 111      is entered into the dynamic symbol table; the loader uses it
 112      to initialize __GOTT_BASE__[__GOTT_INDEX__].  */
 113   if (htab->hgot)
 114     {
 115       htab->hgot->indx = -2;
 116       htab->hgot->other &= ~ELF_ST_VISIBILITY (-1);
 117       htab->hgot->forced_local = 0;
 118       if (!bfd_elf_link_record_dynamic_symbol (info, htab->hgot))
 119         return FALSE;
 120     }
 121   if (htab->hplt)
 122     {
 123       htab->hplt->indx = -2;
 124       htab->hplt->type = STT_FUNC;
 125     }
 126
 127   return TRUE;
 128 }
 129
 130 /* Tweak magic VxWorks symbols as they are written to the output file.  */
 131 int
 132 elf_vxworks_link_output_symbol_hook (struct bfd_link_info *info
 133                                        ATTRIBUTE_UNUSED,
 134                                      const char *name,
 135                                      Elf_Internal_Sym *sym,
 136                                      asection *input_sec ATTRIBUTE_UNUSED,
 137                                      struct elf_link_hash_entry *h)
 138 {
 139   /* Reverse the effects of the hack in elf_vxworks_add_symbol_hook.  */
 140   if (h
 141       && h->root.type == bfd_link_hash_undefweak
 142       && elf_vxworks_gott_symbol_p (h->root.u.undef.abfd, name))
 143     sym->st_info = ELF_ST_INFO (STB_GLOBAL, ELF_ST_TYPE (sym->st_info));
 144
 145   return 1;
 146 }
 147
 148 /* Copy relocations into the output file.  Fixes up relocations against PLT
 149    entries, then calls the generic routine.  */
 150
 151 bfd_boolean
 152 elf_vxworks_emit_relocs (bfd *output_bfd,
 153                          asection *input_section,
 154                          Elf_Internal_Shdr *input_rel_hdr,
 155                          Elf_Internal_Rela *internal_relocs,
 156                          struct elf_link_hash_entry **rel_hash)
 157 {
 158   const struct elf_backend_data *bed;
 159   int j;
 160
 161   bed = get_elf_backend_data (output_bfd);
 162
 163   if (output_bfd->flags & (DYNAMIC|EXEC_P))
 164     {
 165       Elf_Internal_Rela *irela;
 166       Elf_Internal_Rela *irelaend;
 167       struct elf_link_hash_entry **hash_ptr;
 168
 169       for (irela = internal_relocs,
 170              irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
 171                                  * bed->s->int_rels_per_ext_rel),
 172              hash_ptr = rel_hash;
 173            irela < irelaend;
 174            irela += bed->s->int_rels_per_ext_rel,
 175              hash_ptr++)
 176         {
 177           if (*hash_ptr
 178               && (*hash_ptr)->def_dynamic
 179               && !(*hash_ptr)->def_regular
 180               && ((*hash_ptr)->root.type == bfd_link_hash_defined
 181                   || (*hash_ptr)->root.type == bfd_link_hash_defweak)
 182               && (*hash_ptr)->root.u.def.section->output_section != NULL)
 183             {
 184               /* This is a relocation from an executable or shared
 185                  library against a symbol in a different shared
 186                  library.  We are creating a definition in the output
 187                  file but it does not come from any of our normal (.o)
 188                  files. ie. a PLT stub.  Normally this would be a
 189                  relocation against against SHN_UNDEF with the VMA of
 190                  the PLT stub.  This upsets the VxWorks loader.
 191                  Convert it to a section-relative relocation.  This
 192                  gets some other symbols (for instance .dynbss), but
 193                  is conservatively correct.  */
 194               for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
 195                 {
 196                   asection *sec = (*hash_ptr)->root.u.def.section;
 197                   int this_idx = sec->output_section->target_index;
 198
 199                   irela[j].r_info
 200                     = ELF32_R_INFO (this_idx, ELF32_R_TYPE (irela[j].r_info));
 201                   irela[j].r_addend += (*hash_ptr)->root.u.def.value;
 202                   irela[j].r_addend += sec->output_offset;
 203                 }
 204               /* Stop the generic routine adjusting this entry.  */
 205               *hash_ptr = NULL;
 206             }
 207         }
 208     }
 209   return _bfd_elf_link_output_relocs (output_bfd, input_section,
 210                                       input_rel_hdr, internal_relocs,
 211                                       rel_hash);
 212 }
 213
 214
 215 /* Set the sh_link and sh_info fields on the static plt relocation secton.  */
 216
 217 void
 218 elf_vxworks_final_write_processing (bfd *abfd,
 219                                     bfd_boolean linker ATTRIBUTE_UNUSED)
 220 {
 221   asection * sec;
 222   struct bfd_elf_section_data *d;
 223
 224   sec = bfd_get_section_by_name (abfd, ".rel.plt.unloaded");
 225   if (!sec)
 226     sec = bfd_get_section_by_name (abfd, ".rela.plt.unloaded");
 227   if (!sec)
 228     return;
 229   d = elf_section_data (sec);
 230   d->this_hdr.sh_link = elf_onesymtab (abfd);
 231   sec = bfd_get_section_by_name (abfd, ".plt");
 232   if (sec)
 233     d->this_hdr.sh_info = elf_section_data (sec)->this_idx;
 234 }
 235
 236 /* Add the dynamic entries required by VxWorks.  These point to the
 237    tls sections.  */
 238
 239 bfd_boolean
 240 elf_vxworks_add_dynamic_entries (bfd *output_bfd, struct bfd_link_info *info)
 241 {
 242   if (bfd_get_section_by_name (output_bfd, ".tls_data"))
 243     {
 244       if (!_bfd_elf_add_dynamic_entry (info, DT_VX_WRS_TLS_DATA_START, 0)
 245           || !_bfd_elf_add_dynamic_entry (info, DT_VX_WRS_TLS_DATA_SIZE, 0)
 246           || !_bfd_elf_add_dynamic_entry (info, DT_VX_WRS_TLS_DATA_ALIGN, 0))
 247         return FALSE;
 248     }
 249   if (bfd_get_section_by_name (output_bfd, ".tls_vars"))
 250     {
 251       if (!_bfd_elf_add_dynamic_entry (info, DT_VX_WRS_TLS_VARS_START, 0)
 252           || !_bfd_elf_add_dynamic_entry (info, DT_VX_WRS_TLS_VARS_SIZE, 0))
 253         return FALSE;
 254     }
 255   return TRUE;
 256 }
 257
 258 /* If *DYN is one of the VxWorks-specific dynamic entries, then fill
 259    in the value now  and return TRUE.  Otherwise return FALSE.  */
 260
 261 bfd_boolean
 262 elf_vxworks_finish_dynamic_entry (bfd *output_bfd, Elf_Internal_Dyn *dyn)
 263 {
 264   asection *sec;
 265
 266   switch (dyn->d_tag)
 267     {
 268     default:
 269       return FALSE;
 270
 271     case DT_VX_WRS_TLS_DATA_START:
 272       sec = bfd_get_section_by_name (output_bfd, ".tls_data");
 273       dyn->d_un.d_ptr = sec->vma;
 274       break;
 275
 276     case DT_VX_WRS_TLS_DATA_SIZE:
 277       sec = bfd_get_section_by_name (output_bfd, ".tls_data");
 278       dyn->d_un.d_val = sec->size;
 279       break;
 280
 281     case DT_VX_WRS_TLS_DATA_ALIGN:
 282       sec = bfd_get_section_by_name (output_bfd, ".tls_data");
 283       dyn->d_un.d_val
 284         = (bfd_size_type)1 << bfd_get_section_alignment (output_bfd,
 285                                                          sec);
 286       break;
 287
 288     case DT_VX_WRS_TLS_VARS_START:
 289       sec = bfd_get_section_by_name (output_bfd, ".tls_vars");
 290       dyn->d_un.d_ptr = sec->vma;
 291       break;
 292
 293     case DT_VX_WRS_TLS_VARS_SIZE:
 294       sec = bfd_get_section_by_name (output_bfd, ".tls_vars");
 295       dyn->d_un.d_val = sec->size;
 296       break;
 297     }
 298   return TRUE;
 299 }
 300
 301