ld/ldelfgen.c

   1 /* Emulation code used by all ELF targets.
   2    Copyright (C) 1991-2021 Free Software Foundation, Inc.
   3
   4    This file is part of the GNU Binutils.
   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., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "bfdlink.h"
  24 #include "ctf-api.h"
  25 #include "ld.h"
  26 #include "ldmain.h"
  27 #include "ldmisc.h"
  28 #include "ldexp.h"
  29 #include "ldlang.h"
  30 #include "ldctor.h"
  31 #include "elf-bfd.h"
  32 #include "elf/internal.h"
  33 #include "ldelfgen.h"
  34
  35 /* Info attached to an output_section_statement about input sections,
  36    used when sorting SHF_LINK_ORDER sections.  */
  37
  38 struct os_sections
  39 {
  40   /* Size allocated for isec.  */
  41   unsigned int alloc;
  42   /* Used entries in isec.  */
  43   unsigned int count;
  44   /* How many are SHF_LINK_ORDER.  */
  45   unsigned int ordered;
  46   /* Input sections attached to this output section.  */
  47   struct os_sections_input {
  48     lang_input_section_type *is;
  49     unsigned int idx;
  50   } isec[1];
  51 };
  52
  53 /* Add IS to data kept for OS.  */
  54
  55 static bool
  56 add_link_order_input_section (lang_input_section_type *is,
  57                               lang_output_section_statement_type *os)
  58 {
  59   struct os_sections *os_info = os->data;
  60   asection *s;
  61
  62   if (os_info == NULL)
  63     {
  64       os_info = xmalloc (sizeof (*os_info) + 63 * sizeof (*os_info->isec));
  65       os_info->alloc = 64;
  66       os_info->count = 0;
  67       os_info->ordered = 0;
  68       os->data = os_info;
  69     }
  70   if (os_info->count == os_info->alloc)
  71     {
  72       size_t want;
  73       os_info->alloc *= 2;
  74       want = sizeof (*os_info) + (os_info->alloc - 1) * sizeof (*os_info->isec);
  75       os_info = xrealloc (os_info, want);
  76       os->data = os_info;
  77     }
  78   os_info->isec[os_info->count].is = is;
  79   os_info->isec[os_info->count].idx = os_info->count;
  80   os_info->count++;
  81   s = is->section;
  82   if (bfd_get_flavour (s->owner) == bfd_target_elf_flavour
  83       && (s->flags & SEC_LINKER_CREATED) == 0
  84       && elf_linked_to_section (s) != NULL)
  85     os_info->ordered++;
  86   return false;
  87 }
  88
  89 /* Run over the linker's statement list, extracting info about input
  90    sections attached to each output section.  */
  91
  92 static bool
  93 link_order_scan (lang_statement_union_type *u,
  94                  lang_output_section_statement_type *os)
  95 {
  96   asection *s;
  97   bool ret = false;
  98
  99   for (; u != NULL; u = u->header.next)
 100     {
 101       switch (u->header.type)
 102         {
 103         case lang_wild_statement_enum:
 104           if (link_order_scan (u->wild_statement.children.head, os))
 105             ret = true;
 106           break;
 107         case lang_constructors_statement_enum:
 108           if (link_order_scan (constructor_list.head, os))
 109             ret = true;
 110           break;
 111         case lang_output_section_statement_enum:
 112           if (u->output_section_statement.constraint != -1
 113               && link_order_scan (u->output_section_statement.children.head,
 114                                   &u->output_section_statement))
 115             ret = true;
 116           break;
 117         case lang_group_statement_enum:
 118           if (link_order_scan (u->group_statement.children.head, os))
 119             ret = true;
 120           break;
 121         case lang_input_section_enum:
 122           s = u->input_section.section;
 123           if (s->output_section != NULL
 124               && s->output_section->owner == link_info.output_bfd
 125               && (s->output_section->flags & SEC_EXCLUDE) == 0
 126               && ((s->output_section->flags & SEC_HAS_CONTENTS) != 0
 127                   || ((s->output_section->flags & (SEC_LOAD | SEC_THREAD_LOCAL))
 128                       == (SEC_LOAD | SEC_THREAD_LOCAL))))
 129             if (add_link_order_input_section (&u->input_section, os))
 130               ret = true;
 131           break;
 132         default:
 133           break;
 134         }
 135     }
 136   return ret;
 137 }
 138
 139 /* Compare two sections based on the locations of the sections they are
 140    linked to.  Used by fixup_link_order.  */
 141
 142 static int
 143 compare_link_order (const void *a, const void *b)
 144 {
 145   const struct os_sections_input *ai = a;
 146   const struct os_sections_input *bi = b;
 147   asection *asec = NULL;
 148   asection *bsec = NULL;
 149   bfd_vma apos, bpos;
 150
 151   if (bfd_get_flavour (ai->is->section->owner) == bfd_target_elf_flavour)
 152     asec = elf_linked_to_section (ai->is->section);
 153   if (bfd_get_flavour (bi->is->section->owner) == bfd_target_elf_flavour)
 154     bsec = elf_linked_to_section (bi->is->section);
 155
 156   /* Place unordered sections before ordered sections.  */
 157   if (asec == NULL || bsec == NULL)
 158     {
 159       if (bsec != NULL)
 160         return -1;
 161       else if (asec != NULL)
 162         return 1;
 163       return ai->idx - bi->idx;
 164     }
 165
 166   apos = asec->output_section->lma + asec->output_offset;
 167   bpos = bsec->output_section->lma + bsec->output_offset;
 168
 169   if (apos < bpos)
 170     return -1;
 171   else if (apos > bpos)
 172     return 1;
 173
 174   if (! bfd_link_relocatable (&link_info))
 175     {
 176       /* The only way we should get matching LMAs is when the first of
 177          the two sections has zero size, or asec and bsec are the
 178          same section.  */
 179       if (asec->size < bsec->size)
 180         return -1;
 181       else if (asec->size > bsec->size)
 182         return 1;
 183     }
 184
 185   /* If they are both zero size then they almost certainly have the same
 186      VMA and thus are not ordered with respect to each other.  Test VMA
 187      anyway, and fall back to idx to make the result reproducible across
 188      qsort implementations.  */
 189   apos = asec->output_section->vma + asec->output_offset;
 190   bpos = bsec->output_section->vma + bsec->output_offset;
 191   if (apos < bpos)
 192     return -1;
 193   else if (apos > bpos)
 194     return 1;
 195   else
 196     return ai->idx - bi->idx;
 197 }
 198
 199 /* Rearrange sections with SHF_LINK_ORDER into the same order as their
 200    linked sections.  */
 201
 202 static bool
 203 fixup_link_order (lang_output_section_statement_type *os)
 204 {
 205   struct os_sections *os_info = os->data;
 206   unsigned int i, j;
 207   lang_input_section_type **orig_is;
 208   asection **save_s;
 209
 210   for (i = 0; i < os_info->count; i = j)
 211     {
 212       /* Normally a linker script will select SHF_LINK_ORDER sections
 213          with an input section wildcard something like the following:
 214          *(.IA_64.unwind* .gnu.linkonce.ia64unw.*)
 215          However if some other random sections are smashed into an
 216          output section, or if SHF_LINK_ORDER are split up by the
 217          linker script, then we only want to sort sections matching a
 218          given wildcard.  That's the purpose of the pattern test.  */
 219       for (j = i + 1; j < os_info->count; j++)
 220         if (os_info->isec[j].is->pattern != os_info->isec[i].is->pattern)
 221           break;
 222       if (j - i > 1)
 223         qsort (&os_info->isec[i], j - i, sizeof (*os_info->isec),
 224                compare_link_order);
 225     }
 226   for (i = 0; i < os_info->count; i++)
 227     if (os_info->isec[i].idx != i)
 228       break;
 229   if (i == os_info->count)
 230     return false;
 231
 232   /* Now reorder the linker input section statements to reflect the
 233      proper sorting.  The is done by rewriting the existing statements
 234      rather than fiddling with lists, since the only thing we need to
 235      change is the bfd section pointer.  */
 236   orig_is = xmalloc (os_info->count * sizeof (*orig_is));
 237   save_s = xmalloc (os_info->count * sizeof (*save_s));
 238   for (i = 0; i < os_info->count; i++)
 239     {
 240       orig_is[os_info->isec[i].idx] = os_info->isec[i].is;
 241       save_s[i] = os_info->isec[i].is->section;
 242     }
 243   for (i = 0; i < os_info->count; i++)
 244     if (os_info->isec[i].idx != i)
 245       {
 246         orig_is[i]->section = save_s[i];
 247         /* Restore os_info to pristine state before the qsort, for the
 248            next pass over sections.  */
 249         os_info->isec[i].is = orig_is[i];
 250         os_info->isec[i].idx = i;
 251       }
 252   free (save_s);
 253   free (orig_is);
 254   return true;
 255 }
 256
 257 void
 258 ldelf_map_segments (bool need_layout)
 259 {
 260   int tries = 10;
 261   static bool done_link_order_scan = false;
 262
 263   do
 264     {
 265       lang_relax_sections (need_layout);
 266       need_layout = false;
 267
 268       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 269         {
 270           lang_output_section_statement_type *os;
 271           if (!done_link_order_scan)
 272             {
 273               link_order_scan (statement_list.head, NULL);
 274               done_link_order_scan = true;
 275             }
 276           for (os = (void *) lang_os_list.head; os != NULL; os = os->next)
 277             {
 278               struct os_sections *os_info = os->data;
 279               if (os_info != NULL && os_info->ordered != 0)
 280                 {
 281                   if (os_info->ordered != os_info->count
 282                       && bfd_link_relocatable (&link_info))
 283                     {
 284                       einfo (_("%F%P: "
 285                                "%pA has both ordered and unordered sections"),
 286                              os->bfd_section);
 287                       return;
 288                     }
 289                   if (os_info->count > 1
 290                       && fixup_link_order (os))
 291                     need_layout = true;
 292                 }
 293             }
 294         }
 295
 296       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
 297           && !bfd_link_relocatable (&link_info))
 298         {
 299           bfd_size_type phdr_size;
 300
 301           phdr_size = elf_program_header_size (link_info.output_bfd);
 302           /* If we don't have user supplied phdrs, throw away any
 303              previous linker generated program headers.  */
 304           if (lang_phdr_list == NULL)
 305             elf_seg_map (link_info.output_bfd) = NULL;
 306           if (!_bfd_elf_map_sections_to_segments (link_info.output_bfd,
 307                                                   &link_info))
 308             einfo (_("%F%P: map sections to segments failed: %E\n"));
 309
 310           if (phdr_size != elf_program_header_size (link_info.output_bfd))
 311             {
 312               if (tries > 6)
 313                 /* The first few times we allow any change to
 314                    phdr_size .  */
 315                 need_layout = true;
 316               else if (phdr_size
 317                        < elf_program_header_size (link_info.output_bfd))
 318                 /* After that we only allow the size to grow.  */
 319                 need_layout = true;
 320               else
 321                 elf_program_header_size (link_info.output_bfd) = phdr_size;
 322             }
 323         }
 324     }
 325   while (need_layout && --tries);
 326
 327   if (tries == 0)
 328     einfo (_("%F%P: looping in map_segments"));
 329
 330   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
 331       && lang_phdr_list == NULL)
 332     {
 333       /* If we don't have user supplied phdrs, strip zero-sized dynamic
 334          sections and regenerate program headers.  */
 335       const struct elf_backend_data *bed
 336         = get_elf_backend_data (link_info.output_bfd);
 337       if (bed->elf_backend_strip_zero_sized_dynamic_sections
 338           && !bed->elf_backend_strip_zero_sized_dynamic_sections
 339                 (&link_info))
 340           einfo (_("%F%P: failed to strip zero-sized dynamic sections"));
 341     }
 342 }
 343
 344 #ifdef ENABLE_LIBCTF
 345 /* We want to emit CTF early if and only if we are not targetting ELF with this
 346    invocation.  */
 347
 348 int
 349 ldelf_emit_ctf_early (void)
 350 {
 351   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 352     return 0;
 353   return 1;
 354 }
 355
 356 /* Callbacks used to map from bfd types to libctf types, under libctf's
 357    control.  */
 358
 359 struct ctf_strtab_iter_cb_arg
 360 {
 361   struct elf_strtab_hash *strtab;
 362   size_t next_i;
 363   size_t next_idx;
 364 };
 365
 366 /* Return strings from the strtab to libctf, one by one.  Returns NULL when
 367    iteration is complete.  */
 368
 369 static const char *
 370 ldelf_ctf_strtab_iter_cb (uint32_t *offset, void *arg_)
 371 {
 372   bfd_size_type off;
 373   const char *ret;
 374
 375   struct ctf_strtab_iter_cb_arg *arg =
 376     (struct ctf_strtab_iter_cb_arg *) arg_;
 377
 378   /* There is no zeroth string.  */
 379   if (arg->next_i == 0)
 380     arg->next_i = 1;
 381
 382   /* Hunt through strings until we fall off the end or find one with
 383      a nonzero refcount.  */
 384   do
 385     {
 386       if (arg->next_i >= _bfd_elf_strtab_len (arg->strtab))
 387         {
 388           arg->next_i = 0;
 389           return NULL;
 390         }
 391
 392       ret = _bfd_elf_strtab_str (arg->strtab, arg->next_i++, &off);
 393     }
 394   while (ret == NULL);
 395
 396   *offset = off;
 397
 398   /* If we've overflowed, we cannot share any further strings: the CTF
 399      format cannot encode strings with such high offsets.  */
 400   if (*offset != off)
 401     return NULL;
 402
 403   return ret;
 404 }
 405
 406 void
 407 ldelf_acquire_strings_for_ctf
 408   (struct ctf_dict *ctf_output, struct elf_strtab_hash *strtab)
 409 {
 410   struct ctf_strtab_iter_cb_arg args = { strtab, 0, 0 };
 411   if (!ctf_output)
 412     return;
 413
 414   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 415     {
 416       if (ctf_link_add_strtab (ctf_output, ldelf_ctf_strtab_iter_cb,
 417                                &args) < 0)
 418         einfo (_("%F%P: warning: CTF strtab association failed; strings will "
 419                  "not be shared: %s\n"),
 420                ctf_errmsg (ctf_errno (ctf_output)));
 421     }
 422 }
 423
 424 void
 425 ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output, int symidx,
 426                           struct elf_internal_sym *sym)
 427 {
 428   ctf_link_sym_t lsym;
 429
 430   if (!ctf_output)
 431      return;
 432
 433   /* New symbol.  */
 434   if (sym != NULL)
 435     {
 436       lsym.st_name = NULL;
 437       lsym.st_nameidx = sym->st_name;
 438       lsym.st_nameidx_set = 1;
 439       lsym.st_symidx = symidx;
 440       lsym.st_shndx = sym->st_shndx;
 441       lsym.st_type = ELF_ST_TYPE (sym->st_info);
 442       lsym.st_value = sym->st_value;
 443       if (ctf_link_add_linker_symbol (ctf_output, &lsym) < 0)
 444         {
 445           einfo (_("%F%P: warning: CTF symbol addition failed; CTF will "
 446                    "not be tied to symbols: %s\n"),
 447                  ctf_errmsg (ctf_errno (ctf_output)));
 448         }
 449     }
 450   else
 451     {
 452       /* Shuffle all the symbols.  */
 453
 454       if (ctf_link_shuffle_syms (ctf_output) < 0)
 455         einfo (_("%F%P: warning: CTF symbol shuffling failed; CTF will "
 456                  "not be tied to symbols: %s\n"),
 457                ctf_errmsg (ctf_errno (ctf_output)));
 458     }
 459 }
 460 #else
 461 int
 462 ldelf_emit_ctf_early (void)
 463 {
 464   return 0;
 465 }
 466
 467 void
 468 ldelf_acquire_strings_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED,
 469                                struct elf_strtab_hash *strtab ATTRIBUTE_UNUSED)
 470 {}
 471 void
 472 ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED,
 473                           int symidx ATTRIBUTE_UNUSED,
 474                           struct elf_internal_sym *sym ATTRIBUTE_UNUSED)
 475 {}
 476 #endif