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
 177          the first of the two sections has zero size.  */
 178       if (asec->size < bsec->size)
 179         return -1;
 180       else if (asec->size > bsec->size)
 181         return 1;
 182     }
 183
 184   /* If they are both zero size then they almost certainly have the same
 185      VMA and thus are not ordered with respect to each other.  Test VMA
 186      anyway, and fall back to id to make the result reproducible across
 187      qsort implementations.  */
 188   apos = asec->output_section->vma + asec->output_offset;
 189   bpos = bsec->output_section->vma + bsec->output_offset;
 190   if (apos < bpos)
 191     return -1;
 192   else if (apos > bpos)
 193     return 1;
 194
 195   return asec->id - bsec->id;
 196 }
 197
 198 /* Rearrange sections with SHF_LINK_ORDER into the same order as their
 199    linked sections.  */
 200
 201 static bool
 202 fixup_link_order (lang_output_section_statement_type *os)
 203 {
 204   struct os_sections *os_info = os->data;
 205   unsigned int i, j;
 206   lang_input_section_type **orig_is;
 207   asection **save_s;
 208
 209   for (i = 0; i < os_info->count; i = j)
 210     {
 211       /* Normally a linker script will select SHF_LINK_ORDER sections
 212          with an input section wildcard something like the following:
 213          *(.IA_64.unwind* .gnu.linkonce.ia64unw.*)
 214          However if some other random sections are smashed into an
 215          output section, or if SHF_LINK_ORDER are split up by the
 216          linker script, then we only want to sort sections matching a
 217          given wildcard.  That's the purpose of the pattern test.  */
 218       for (j = i + 1; j < os_info->count; j++)
 219         if (os_info->isec[j].is->pattern != os_info->isec[i].is->pattern)
 220           break;
 221       if (j - i > 1)
 222         qsort (&os_info->isec[i], j - i, sizeof (*os_info->isec),
 223                compare_link_order);
 224     }
 225   for (i = 0; i < os_info->count; i++)
 226     if (os_info->isec[i].idx != i)
 227       break;
 228   if (i == os_info->count)
 229     return false;
 230
 231   /* Now reorder the linker input section statements to reflect the
 232      proper sorting.  The is done by rewriting the existing statements
 233      rather than fiddling with lists, since the only thing we need to
 234      change is the bfd section pointer.  */
 235   orig_is = xmalloc (os_info->count * sizeof (*orig_is));
 236   save_s = xmalloc (os_info->count * sizeof (*save_s));
 237   for (i = 0; i < os_info->count; i++)
 238     {
 239       orig_is[os_info->isec[i].idx] = os_info->isec[i].is;
 240       save_s[i] = os_info->isec[i].is->section;
 241     }
 242   for (i = 0; i < os_info->count; i++)
 243     if (os_info->isec[i].idx != i)
 244       {
 245         orig_is[i]->section = save_s[i];
 246         /* Restore os_info to pristine state before the qsort, for the
 247            next pass over sections.  */
 248         os_info->isec[i].is = orig_is[i];
 249         os_info->isec[i].idx = i;
 250       }
 251   free (save_s);
 252   free (orig_is);
 253   return true;
 254 }
 255
 256 void
 257 ldelf_map_segments (bool need_layout)
 258 {
 259   int tries = 10;
 260   static bool done_link_order_scan = false;
 261
 262   do
 263     {
 264       lang_relax_sections (need_layout);
 265       need_layout = false;
 266
 267       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 268         {
 269           lang_output_section_statement_type *os;
 270           if (!done_link_order_scan)
 271             {
 272               link_order_scan (statement_list.head, NULL);
 273               done_link_order_scan = true;
 274             }
 275           for (os = (void *) lang_os_list.head; os != NULL; os = os->next)
 276             {
 277               struct os_sections *os_info = os->data;
 278               if (os_info != NULL && os_info->ordered != 0)
 279                 {
 280                   if (os_info->ordered != os_info->count
 281                       && bfd_link_relocatable (&link_info))
 282                     {
 283                       einfo (_("%F%P: "
 284                                "%pA has both ordered and unordered sections"),
 285                              os->bfd_section);
 286                       return;
 287                     }
 288                   if (os_info->count > 1
 289                       && fixup_link_order (os))
 290                     need_layout = true;
 291                 }
 292             }
 293         }
 294
 295       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
 296           && !bfd_link_relocatable (&link_info))
 297         {
 298           bfd_size_type phdr_size;
 299
 300           phdr_size = elf_program_header_size (link_info.output_bfd);
 301           /* If we don't have user supplied phdrs, throw away any
 302              previous linker generated program headers.  */
 303           if (lang_phdr_list == NULL)
 304             elf_seg_map (link_info.output_bfd) = NULL;
 305           if (!_bfd_elf_map_sections_to_segments (link_info.output_bfd,
 306                                                   &link_info))
 307             einfo (_("%F%P: map sections to segments failed: %E\n"));
 308
 309           if (phdr_size != elf_program_header_size (link_info.output_bfd))
 310             {
 311               if (tries > 6)
 312                 /* The first few times we allow any change to
 313                    phdr_size .  */
 314                 need_layout = true;
 315               else if (phdr_size
 316                        < elf_program_header_size (link_info.output_bfd))
 317                 /* After that we only allow the size to grow.  */
 318                 need_layout = true;
 319               else
 320                 elf_program_header_size (link_info.output_bfd) = phdr_size;
 321             }
 322         }
 323     }
 324   while (need_layout && --tries);
 325
 326   if (tries == 0)
 327     einfo (_("%F%P: looping in map_segments"));
 328
 329   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
 330       && lang_phdr_list == NULL)
 331     {
 332       /* If we don't have user supplied phdrs, strip zero-sized dynamic
 333          sections and regenerate program headers.  */
 334       const struct elf_backend_data *bed
 335         = get_elf_backend_data (link_info.output_bfd);
 336       if (bed->elf_backend_strip_zero_sized_dynamic_sections
 337           && !bed->elf_backend_strip_zero_sized_dynamic_sections
 338                 (&link_info))
 339           einfo (_("%F%P: failed to strip zero-sized dynamic sections"));
 340     }
 341 }
 342
 343 #ifdef ENABLE_LIBCTF
 344 /* We want to emit CTF early if and only if we are not targetting ELF with this
 345    invocation.  */
 346
 347 int
 348 ldelf_emit_ctf_early (void)
 349 {
 350   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 351     return 0;
 352   return 1;
 353 }
 354
 355 /* Callbacks used to map from bfd types to libctf types, under libctf's
 356    control.  */
 357
 358 struct ctf_strtab_iter_cb_arg
 359 {
 360   struct elf_strtab_hash *strtab;
 361   size_t next_i;
 362   size_t next_idx;
 363 };
 364
 365 /* Return strings from the strtab to libctf, one by one.  Returns NULL when
 366    iteration is complete.  */
 367
 368 static const char *
 369 ldelf_ctf_strtab_iter_cb (uint32_t *offset, void *arg_)
 370 {
 371   bfd_size_type off;
 372   const char *ret;
 373
 374   struct ctf_strtab_iter_cb_arg *arg =
 375     (struct ctf_strtab_iter_cb_arg *) arg_;
 376
 377   /* There is no zeroth string.  */
 378   if (arg->next_i == 0)
 379     arg->next_i = 1;
 380
 381   /* Hunt through strings until we fall off the end or find one with
 382      a nonzero refcount.  */
 383   do
 384     {
 385       if (arg->next_i >= _bfd_elf_strtab_len (arg->strtab))
 386         {
 387           arg->next_i = 0;
 388           return NULL;
 389         }
 390
 391       ret = _bfd_elf_strtab_str (arg->strtab, arg->next_i++, &off);
 392     }
 393   while (ret == NULL);
 394
 395   *offset = off;
 396
 397   /* If we've overflowed, we cannot share any further strings: the CTF
 398      format cannot encode strings with such high offsets.  */
 399   if (*offset != off)
 400     return NULL;
 401
 402   return ret;
 403 }
 404
 405 void
 406 ldelf_acquire_strings_for_ctf
 407   (struct ctf_dict *ctf_output, struct elf_strtab_hash *strtab)
 408 {
 409   struct ctf_strtab_iter_cb_arg args = { strtab, 0, 0 };
 410   if (!ctf_output)
 411     return;
 412
 413   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 414     {
 415       if (ctf_link_add_strtab (ctf_output, ldelf_ctf_strtab_iter_cb,
 416                                &args) < 0)
 417         einfo (_("%F%P: warning: CTF strtab association failed; strings will "
 418                  "not be shared: %s\n"),
 419                ctf_errmsg (ctf_errno (ctf_output)));
 420     }
 421 }
 422
 423 void
 424 ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output, int symidx,
 425                           struct elf_internal_sym *sym)
 426 {
 427   ctf_link_sym_t lsym;
 428
 429   if (!ctf_output)
 430      return;
 431
 432   /* New symbol.  */
 433   if (sym != NULL)
 434     {
 435       lsym.st_name = NULL;
 436       lsym.st_nameidx = sym->st_name;
 437       lsym.st_nameidx_set = 1;
 438       lsym.st_symidx = symidx;
 439       lsym.st_shndx = sym->st_shndx;
 440       lsym.st_type = ELF_ST_TYPE (sym->st_info);
 441       lsym.st_value = sym->st_value;
 442       if (ctf_link_add_linker_symbol (ctf_output, &lsym) < 0)
 443         {
 444           einfo (_("%F%P: warning: CTF symbol addition failed; CTF will "
 445                    "not be tied to symbols: %s\n"),
 446                  ctf_errmsg (ctf_errno (ctf_output)));
 447         }
 448     }
 449   else
 450     {
 451       /* Shuffle all the symbols.  */
 452
 453       if (ctf_link_shuffle_syms (ctf_output) < 0)
 454         einfo (_("%F%P: warning: CTF symbol shuffling failed; CTF will "
 455                  "not be tied to symbols: %s\n"),
 456                ctf_errmsg (ctf_errno (ctf_output)));
 457     }
 458 }
 459 #else
 460 int
 461 ldelf_emit_ctf_early (void)
 462 {
 463   return 0;
 464 }
 465
 466 void
 467 ldelf_acquire_strings_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED,
 468                                struct elf_strtab_hash *strtab ATTRIBUTE_UNUSED)
 469 {}
 470 void
 471 ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED,
 472                           int symidx ATTRIBUTE_UNUSED,
 473                           struct elf_internal_sym *sym ATTRIBUTE_UNUSED)
 474 {}
 475 #endif