ld/ldelfgen.c

   1 /* Emulation code used by all ELF targets.
   2    Copyright (C) 1991-2023 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\n"),
 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                                                   &need_layout))
 309             einfo (_("%F%P: map sections to segments failed: %E\n"));
 310
 311           if (phdr_size != elf_program_header_size (link_info.output_bfd))
 312             {
 313               if (tries > 6)
 314                 /* The first few times we allow any change to
 315                    phdr_size .  */
 316                 need_layout = true;
 317               else if (phdr_size
 318                        < elf_program_header_size (link_info.output_bfd))
 319                 /* After that we only allow the size to grow.  */
 320                 need_layout = true;
 321               else
 322                 elf_program_header_size (link_info.output_bfd) = phdr_size;
 323             }
 324         }
 325     }
 326   while (need_layout && --tries);
 327
 328   if (tries == 0)
 329     einfo (_("%F%P: looping in map_segments\n"));
 330
 331   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
 332       && lang_phdr_list == NULL)
 333     {
 334       /* If we don't have user supplied phdrs, strip zero-sized dynamic
 335          sections and regenerate program headers.  */
 336       const struct elf_backend_data *bed
 337         = get_elf_backend_data (link_info.output_bfd);
 338       if (bed->elf_backend_strip_zero_sized_dynamic_sections
 339           && !bed->elf_backend_strip_zero_sized_dynamic_sections
 340                 (&link_info))
 341           einfo (_("%F%P: failed to strip zero-sized dynamic sections\n"));
 342     }
 343 }
 344
 345 #ifdef ENABLE_LIBCTF
 346 /* We want to emit CTF early if and only if we are not targetting ELF with this
 347    invocation.  */
 348
 349 int
 350 ldelf_emit_ctf_early (void)
 351 {
 352   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 353     return 0;
 354   return 1;
 355 }
 356
 357 /* Callbacks used to map from bfd types to libctf types, under libctf's
 358    control.  */
 359
 360 struct ctf_strtab_iter_cb_arg
 361 {
 362   struct elf_strtab_hash *strtab;
 363   size_t next_i;
 364   size_t next_idx;
 365 };
 366
 367 /* Return strings from the strtab to libctf, one by one.  Returns NULL when
 368    iteration is complete.  */
 369
 370 static const char *
 371 ldelf_ctf_strtab_iter_cb (uint32_t *offset, void *arg_)
 372 {
 373   bfd_size_type off;
 374   const char *ret;
 375
 376   struct ctf_strtab_iter_cb_arg *arg =
 377     (struct ctf_strtab_iter_cb_arg *) arg_;
 378
 379   /* There is no zeroth string.  */
 380   if (arg->next_i == 0)
 381     arg->next_i = 1;
 382
 383   /* Hunt through strings until we fall off the end or find one with
 384      a nonzero refcount.  */
 385   do
 386     {
 387       if (arg->next_i >= _bfd_elf_strtab_len (arg->strtab))
 388         {
 389           arg->next_i = 0;
 390           return NULL;
 391         }
 392
 393       ret = _bfd_elf_strtab_str (arg->strtab, arg->next_i++, &off);
 394     }
 395   while (ret == NULL);
 396
 397   *offset = off;
 398
 399   /* If we've overflowed, we cannot share any further strings: the CTF
 400      format cannot encode strings with such high offsets.  */
 401   if (*offset != off)
 402     return NULL;
 403
 404   return ret;
 405 }
 406
 407 void
 408 ldelf_acquire_strings_for_ctf
 409   (struct ctf_dict *ctf_output, struct elf_strtab_hash *strtab)
 410 {
 411   struct ctf_strtab_iter_cb_arg args = { strtab, 0, 0 };
 412   if (!ctf_output)
 413     return;
 414
 415   if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 416     {
 417       if (ctf_link_add_strtab (ctf_output, ldelf_ctf_strtab_iter_cb,
 418                                &args) < 0)
 419         einfo (_("%F%P: warning: CTF strtab association failed; strings will "
 420                  "not be shared: %s\n"),
 421                ctf_errmsg (ctf_errno (ctf_output)));
 422     }
 423 }
 424
 425 void
 426 ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output, int symidx,
 427                           struct elf_internal_sym *sym)
 428 {
 429   ctf_link_sym_t lsym;
 430
 431   if (!ctf_output)
 432      return;
 433
 434   /* New symbol.  */
 435   if (sym != NULL)
 436     {
 437       lsym.st_name = NULL;
 438       lsym.st_nameidx = sym->st_name;
 439       lsym.st_nameidx_set = 1;
 440       lsym.st_symidx = symidx;
 441       lsym.st_shndx = sym->st_shndx;
 442       lsym.st_type = ELF_ST_TYPE (sym->st_info);
 443       lsym.st_value = sym->st_value;
 444       if (ctf_link_add_linker_symbol (ctf_output, &lsym) < 0)
 445         {
 446           einfo (_("%F%P: warning: CTF symbol addition failed; CTF will "
 447                    "not be tied to symbols: %s\n"),
 448                  ctf_errmsg (ctf_errno (ctf_output)));
 449         }
 450     }
 451   else
 452     {
 453       /* Shuffle all the symbols.  */
 454
 455       if (ctf_link_shuffle_syms (ctf_output) < 0)
 456         einfo (_("%F%P: warning: CTF symbol shuffling failed; CTF will "
 457                  "not be tied to symbols: %s\n"),
 458                ctf_errmsg (ctf_errno (ctf_output)));
 459     }
 460 }
 461 #else
 462 int
 463 ldelf_emit_ctf_early (void)
 464 {
 465   return 0;
 466 }
 467
 468 void
 469 ldelf_acquire_strings_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED,
 470                                struct elf_strtab_hash *strtab ATTRIBUTE_UNUSED)
 471 {}
 472 void
 473 ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED,
 474                           int symidx ATTRIBUTE_UNUSED,
 475                           struct elf_internal_sym *sym ATTRIBUTE_UNUSED)
 476 {}
 477 #endif