[deliverable/binutils-gdb.git] / ld / ldelfgen.c

/* Emulation code used by all ELF targets.
   Copyright (C) 1991-2021 Free Software Foundation, Inc.

   This file is part of the GNU Binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include "sysdep.h"
#include "bfd.h"
#include "bfdlink.h"
#include "ctf-api.h"
#include "ld.h"
#include "ldmain.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldctor.h"
#include "elf-bfd.h"
#include "elf/internal.h"
#include "ldelfgen.h"

/* Info attached to an output_section_statement about input sections,
   used when sorting SHF_LINK_ORDER sections.  */

struct os_sections
{
  /* Size allocated for isec.  */
  unsigned int alloc;
  /* Used entries in isec.  */
  unsigned int count;
  /* How many are SHF_LINK_ORDER.  */
  unsigned int ordered;
  /* Input sections attached to this output section.  */
  struct os_sections_input {
    lang_input_section_type *is;
    unsigned int idx;
  } isec[1];
};

/* Add IS to data kept for OS.  */

static bool
add_link_order_input_section (lang_input_section_type *is,
			      lang_output_section_statement_type *os)
{
  struct os_sections *os_info = os->data;
  asection *s;

  if (os_info == NULL)
    {
      os_info = xmalloc (sizeof (*os_info) + 63 * sizeof (*os_info->isec));
      os_info->alloc = 64;
      os_info->count = 0;
      os_info->ordered = 0;
      os->data = os_info;
    }
  if (os_info->count == os_info->alloc)
    {
      size_t want;
      os_info->alloc *= 2;
      want = sizeof (*os_info) + (os_info->alloc - 1) * sizeof (*os_info->isec);
      os_info = xrealloc (os_info, want);
      os->data = os_info;
    }
  os_info->isec[os_info->count].is = is;
  os_info->isec[os_info->count].idx = os_info->count;
  os_info->count++;
  s = is->section;
  if (bfd_get_flavour (s->owner) == bfd_target_elf_flavour
      && (s->flags & SEC_LINKER_CREATED) == 0
      && elf_linked_to_section (s) != NULL)
    os_info->ordered++;
  return false;
}

/* Run over the linker's statement list, extracting info about input
   sections attached to each output section.  */

static bool
link_order_scan (lang_statement_union_type *u,
		 lang_output_section_statement_type *os)
{
  asection *s;
  bool ret = false;

  for (; u != NULL; u = u->header.next)
    {
      switch (u->header.type)
	{
	case lang_wild_statement_enum:
	  if (link_order_scan (u->wild_statement.children.head, os))
	    ret = true;
	  break;
	case lang_constructors_statement_enum:
	  if (link_order_scan (constructor_list.head, os))
	    ret = true;
	  break;
	case lang_output_section_statement_enum:
	  if (u->output_section_statement.constraint != -1
	      && link_order_scan (u->output_section_statement.children.head,
				  &u->output_section_statement))
	    ret = true;
	  break;
	case lang_group_statement_enum:
	  if (link_order_scan (u->group_statement.children.head, os))
	    ret = true;
	  break;
	case lang_input_section_enum:
	  s = u->input_section.section;
	  if (s->output_section != NULL
	      && s->output_section->owner == link_info.output_bfd
	      && (s->output_section->flags & SEC_EXCLUDE) == 0
	      && ((s->output_section->flags & SEC_HAS_CONTENTS) != 0
		  || ((s->output_section->flags & (SEC_LOAD | SEC_THREAD_LOCAL))
		      == (SEC_LOAD | SEC_THREAD_LOCAL))))
	    if (add_link_order_input_section (&u->input_section, os))
	      ret = true;
	  break;
	default:
	  break;
	}
    }
  return ret;
}

/* Compare two sections based on the locations of the sections they are
   linked to.  Used by fixup_link_order.  */

static int
compare_link_order (const void *a, const void *b)
{
  const struct os_sections_input *ai = a;
  const struct os_sections_input *bi = b;
  asection *asec = NULL;
  asection *bsec = NULL;
  bfd_vma apos, bpos;

  if (bfd_get_flavour (ai->is->section->owner) == bfd_target_elf_flavour)
    asec = elf_linked_to_section (ai->is->section);
  if (bfd_get_flavour (bi->is->section->owner) == bfd_target_elf_flavour)
    bsec = elf_linked_to_section (bi->is->section);

  /* Place unordered sections before ordered sections.  */
  if (asec == NULL || bsec == NULL)
    {
      if (bsec != NULL)
	return -1;
      else if (asec != NULL)
	return 1;
      return ai->idx - bi->idx;
    }

  apos = asec->output_section->lma + asec->output_offset;
  bpos = bsec->output_section->lma + bsec->output_offset;

  if (apos < bpos)
    return -1;
  else if (apos > bpos)
    return 1;

  if (! bfd_link_relocatable (&link_info))
    {
      /* The only way we should get matching LMAs is when
	 the first of the two sections has zero size.  */
      if (asec->size < bsec->size)
	return -1;
      else if (asec->size > bsec->size)
	return 1;
    }

  /* If they are both zero size then they almost certainly have the same
     VMA and thus are not ordered with respect to each other.  Test VMA
     anyway, and fall back to id to make the result reproducible across
     qsort implementations.  */
  apos = asec->output_section->vma + asec->output_offset;
  bpos = bsec->output_section->vma + bsec->output_offset;
  if (apos < bpos)
    return -1;
  else if (apos > bpos)
    return 1;

  return asec->id - bsec->id;
}

/* Rearrange sections with SHF_LINK_ORDER into the same order as their
   linked sections.  */

static bool
fixup_link_order (lang_output_section_statement_type *os)
{
  struct os_sections *os_info = os->data;
  unsigned int i, j;
  lang_input_section_type **orig_is;
  asection **save_s;

  for (i = 0; i < os_info->count; i = j)
    {
      /* Normally a linker script will select SHF_LINK_ORDER sections
	 with an input section wildcard something like the following:
	 *(.IA_64.unwind* .gnu.linkonce.ia64unw.*)
	 However if some other random sections are smashed into an
	 output section, or if SHF_LINK_ORDER are split up by the
	 linker script, then we only want to sort sections matching a
	 given wildcard.  That's the purpose of the pattern test.  */
      for (j = i + 1; j < os_info->count; j++)
	if (os_info->isec[j].is->pattern != os_info->isec[i].is->pattern)
	  break;
      if (j - i > 1)
	qsort (&os_info->isec[i], j - i, sizeof (*os_info->isec),
	       compare_link_order);
    }
  for (i = 0; i < os_info->count; i++)
    if (os_info->isec[i].idx != i)
      break;
  if (i == os_info->count)
    return false;

  /* Now reorder the linker input section statements to reflect the
     proper sorting.  The is done by rewriting the existing statements
     rather than fiddling with lists, since the only thing we need to
     change is the bfd section pointer.  */
  orig_is = xmalloc (os_info->count * sizeof (*orig_is));
  save_s = xmalloc (os_info->count * sizeof (*save_s));
  for (i = 0; i < os_info->count; i++)
    {
      orig_is[os_info->isec[i].idx] = os_info->isec[i].is;
      save_s[i] = os_info->isec[i].is->section;
    }
  for (i = 0; i < os_info->count; i++)
    if (os_info->isec[i].idx != i)
      {
	orig_is[i]->section = save_s[i];
	/* Restore os_info to pristine state before the qsort, for the
	   next pass over sections.  */
	os_info->isec[i].is = orig_is[i];
	os_info->isec[i].idx = i;
      }
  free (save_s);
  free (orig_is);
  return true;
}

void
ldelf_map_segments (bool need_layout)
{
  int tries = 10;
  static bool done_link_order_scan = false;

  do
    {
      lang_relax_sections (need_layout);
      need_layout = false;

      if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
	{
	  lang_output_section_statement_type *os;
	  if (!done_link_order_scan)
	    {
	      link_order_scan (statement_list.head, NULL);
	      done_link_order_scan = true;
	    }
	  for (os = (void *) lang_os_list.head; os != NULL; os = os->next)
	    {
	      struct os_sections *os_info = os->data;
	      if (os_info != NULL && os_info->ordered != 0)
		{
		  if (os_info->ordered != os_info->count
		      && bfd_link_relocatable (&link_info))
		    {
		      einfo (_("%F%P: "
			       "%pA has both ordered and unordered sections"),
			     os->bfd_section);
		      return;
		    }
		  if (os_info->count > 1
		      && fixup_link_order (os))
		    need_layout = true;
		}
	    }
	}

      if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
	  && !bfd_link_relocatable (&link_info))
	{
	  bfd_size_type phdr_size;

	  phdr_size = elf_program_header_size (link_info.output_bfd);
	  /* If we don't have user supplied phdrs, throw away any
	     previous linker generated program headers.  */
	  if (lang_phdr_list == NULL)
	    elf_seg_map (link_info.output_bfd) = NULL;
	  if (!_bfd_elf_map_sections_to_segments (link_info.output_bfd,
						  &link_info))
	    einfo (_("%F%P: map sections to segments failed: %E\n"));

	  if (phdr_size != elf_program_header_size (link_info.output_bfd))
	    {
	      if (tries > 6)
		/* The first few times we allow any change to
		   phdr_size .  */
		need_layout = true;
	      else if (phdr_size
		       < elf_program_header_size (link_info.output_bfd))
		/* After that we only allow the size to grow.  */
		need_layout = true;
	      else
		elf_program_header_size (link_info.output_bfd) = phdr_size;
	    }
	}
    }
  while (need_layout && --tries);

  if (tries == 0)
    einfo (_("%F%P: looping in map_segments"));

  if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
      && lang_phdr_list == NULL)
    {
      /* If we don't have user supplied phdrs, strip zero-sized dynamic
	 sections and regenerate program headers.  */
      const struct elf_backend_data *bed
	= get_elf_backend_data (link_info.output_bfd);
      if (bed->elf_backend_strip_zero_sized_dynamic_sections
	  && !bed->elf_backend_strip_zero_sized_dynamic_sections
		(&link_info))
	  einfo (_("%F%P: failed to strip zero-sized dynamic sections"));
    }
}

#ifdef ENABLE_LIBCTF
/* We want to emit CTF early if and only if we are not targetting ELF with this
   invocation.  */

int
ldelf_emit_ctf_early (void)
{
  if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
    return 0;
  return 1;
}

/* Callbacks used to map from bfd types to libctf types, under libctf's
   control.  */

struct ctf_strtab_iter_cb_arg
{
  struct elf_strtab_hash *strtab;
  size_t next_i;
  size_t next_idx;
};

/* Return strings from the strtab to libctf, one by one.  Returns NULL when
   iteration is complete.  */

static const char *
ldelf_ctf_strtab_iter_cb (uint32_t *offset, void *arg_)
{
  bfd_size_type off;
  const char *ret;

  struct ctf_strtab_iter_cb_arg *arg =
    (struct ctf_strtab_iter_cb_arg *) arg_;

  /* There is no zeroth string.  */
  if (arg->next_i == 0)
    arg->next_i = 1;

  /* Hunt through strings until we fall off the end or find one with
     a nonzero refcount.  */
  do
    {
      if (arg->next_i >= _bfd_elf_strtab_len (arg->strtab))
	{
	  arg->next_i = 0;
	  return NULL;
	}

      ret = _bfd_elf_strtab_str (arg->strtab, arg->next_i++, &off);
    }
  while (ret == NULL);

  *offset = off;

  /* If we've overflowed, we cannot share any further strings: the CTF
     format cannot encode strings with such high offsets.  */
  if (*offset != off)
    return NULL;

  return ret;
}

void
ldelf_acquire_strings_for_ctf
  (struct ctf_dict *ctf_output, struct elf_strtab_hash *strtab)
{
  struct ctf_strtab_iter_cb_arg args = { strtab, 0, 0 };
  if (!ctf_output)
    return;

  if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
    {
      if (ctf_link_add_strtab (ctf_output, ldelf_ctf_strtab_iter_cb,
			       &args) < 0)
	einfo (_("%F%P: warning: CTF strtab association failed; strings will "
		 "not be shared: %s\n"),
	       ctf_errmsg (ctf_errno (ctf_output)));
    }
}

void
ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output, int symidx,
			  struct elf_internal_sym *sym)
{
  ctf_link_sym_t lsym;

  if (!ctf_output)
     return;

  /* New symbol.  */
  if (sym != NULL)
    {
      lsym.st_name = NULL;
      lsym.st_nameidx = sym->st_name;
      lsym.st_nameidx_set = 1;
      lsym.st_symidx = symidx;
      lsym.st_shndx = sym->st_shndx;
      lsym.st_type = ELF_ST_TYPE (sym->st_info);
      lsym.st_value = sym->st_value;
      if (ctf_link_add_linker_symbol (ctf_output, &lsym) < 0)
	{
	  einfo (_("%F%P: warning: CTF symbol addition failed; CTF will "
		   "not be tied to symbols: %s\n"),
		 ctf_errmsg (ctf_errno (ctf_output)));
	}
    }
  else
    {
      /* Shuffle all the symbols.  */

      if (ctf_link_shuffle_syms (ctf_output) < 0)
	einfo (_("%F%P: warning: CTF symbol shuffling failed; CTF will "
		 "not be tied to symbols: %s\n"),
	       ctf_errmsg (ctf_errno (ctf_output)));
    }
}
#else
int
ldelf_emit_ctf_early (void)
{
  return 0;
}

void
ldelf_acquire_strings_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED,
			       struct elf_strtab_hash *strtab ATTRIBUTE_UNUSED)
{}
void
ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output ATTRIBUTE_UNUSED,
			  int symidx ATTRIBUTE_UNUSED,
			  struct elf_internal_sym *sym ATTRIBUTE_UNUSED)
{}
#endif
Commit	Line	Data
d871d478	1	/* Emulation code used by all ELF targets.
250d07de	2	Copyright (C) 1991-2021 Free Software Foundation, Inc.
d871d478 AM	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"
0b4453c7	23	#include "bfdlink.h"
1ff6de03	24	#include "ctf-api.h"
d871d478 AM	25	#include "ld.h"
	26	#include "ldmain.h"
	27	#include "ldmisc.h"
	28	#include "ldexp.h"
	29	#include "ldlang.h"
b209b5a6	30	#include "ldctor.h"
d871d478	31	#include "elf-bfd.h"
3d16b64e	32	#include "elf/internal.h"
d871d478 AM	33	#include "ldelfgen.h"
d871d478 AM	34
b209b5a6 AM	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
f38a2680	55	static bool
b209b5a6 AM	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;
4120e488	82	if (bfd_get_flavour (s->owner) == bfd_target_elf_flavour
b634d11d	83	&& (s->flags & SEC_LINKER_CREATED) == 0
b209b5a6 AM	84	&& elf_linked_to_section (s) != NULL)
b209b5a6 AM	85	os_info->ordered++;
f38a2680	86	return false;
b209b5a6 AM	87	}
	88
	89	/* Run over the linker's statement list, extracting info about input
	90	sections attached to each output section. */
	91
f38a2680	92	static bool
b209b5a6 AM	93	link_order_scan (lang_statement_union_type *u,
	94	lang_output_section_statement_type *os)
	95	{
	96	asection *s;
f38a2680	97	bool ret = false;
b209b5a6 AM	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))
f38a2680	105	ret = true;
b209b5a6 AM	106	break;
	107	case lang_constructors_statement_enum:
	108	if (link_order_scan (constructor_list.head, os))
f38a2680	109	ret = true;
b209b5a6 AM	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))
f38a2680	115	ret = true;
b209b5a6 AM	116	break;
	117	case lang_group_statement_enum:
	118	if (link_order_scan (u->group_statement.children.head, os))
f38a2680	119	ret = true;
b209b5a6 AM	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))
f38a2680	130	ret = true;
b209b5a6 AM	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;
4120e488 AM	147	asection *asec = NULL;
4120e488 AM	148	asection *bsec = NULL;
b209b5a6 AM	149	bfd_vma apos, bpos;
b209b5a6 AM	150
4120e488 AM	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
b209b5a6 AM	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
d820a652 NC	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	}
b209b5a6 AM	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
f38a2680	201	static bool
b209b5a6 AM	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)
f38a2680	229	return false;
b209b5a6 AM	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);
f38a2680	253	return true;
b209b5a6 AM	254	}
b209b5a6 AM	255
d871d478	256	void
f38a2680	257	ldelf_map_segments (bool need_layout)
d871d478 AM	258	{
d871d478 AM	259	int tries = 10;
f38a2680	260	static bool done_link_order_scan = false;
d871d478 AM	261
	262	do
	263	{
	264	lang_relax_sections (need_layout);
f38a2680	265	need_layout = false;
d871d478	266
4120e488	267	if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
b209b5a6 AM	268	{
	269	lang_output_section_statement_type *os;
	270	if (!done_link_order_scan)
	271	{
	272	link_order_scan (statement_list.head, NULL);
f38a2680	273	done_link_order_scan = true;
b209b5a6 AM	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))
f38a2680	290	need_layout = true;
b209b5a6 AM	291	}
	292	}
	293	}
	294
4120e488	295	if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
d871d478 AM	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 . */
f38a2680	314	need_layout = true;
d871d478 AM	315	else if (phdr_size
	316	< elf_program_header_size (link_info.output_bfd))
	317	/* After that we only allow the size to grow. */
f38a2680	318	need_layout = true;
d871d478 AM	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"));
6f6fd151	328
4120e488	329	if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
6f6fd151 L	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	}
d871d478	341	}
1ff6de03	342
094e34f2	343	#ifdef ENABLE_LIBCTF
1ff6de03 NA	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
3d16b64e	358	struct ctf_strtab_iter_cb_arg
1ff6de03	359	{
3d16b64e	360	struct elf_strtab_hash *strtab;
1ff6de03 NA	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
3d16b64e NA	374	struct ctf_strtab_iter_cb_arg *arg =
3d16b64e NA	375	(struct ctf_strtab_iter_cb_arg *) arg_;
1ff6de03 NA	376
	377	/* There is no zeroth string. */
	378	if (arg->next_i == 0)
	379	arg->next_i = 1;
	380
211bcd01 NA	381	/* Hunt through strings until we fall off the end or find one with
	382	a nonzero refcount. */
	383	do
1ff6de03	384	{
211bcd01 NA	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);
1ff6de03	392	}
211bcd01	393	while (ret == NULL);
1ff6de03	394
1ff6de03 NA	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
3d16b64e NA	405	void
	406	ldelf_acquire_strings_for_ctf
	407	(struct ctf_dict ctf_output, struct elf_strtab_hash strtab)
1ff6de03	408	{
3d16b64e NA	409	struct ctf_strtab_iter_cb_arg args = { strtab, 0, 0 };
	410	if (!ctf_output)
	411	return;
1ff6de03	412
3d16b64e	413	if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
1ff6de03	414	{
3d16b64e NA	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)));
1ff6de03	420	}
1ff6de03 NA	421	}
	422
	423	void
3d16b64e NA	424	ldelf_new_dynsym_for_ctf (struct ctf_dict *ctf_output, int symidx,
3d16b64e NA	425	struct elf_internal_sym *sym)
1ff6de03	426	{
3d16b64e NA	427	ctf_link_sym_t lsym;
	428
	429	if (!ctf_output)
1ff6de03 NA	430	return;
1ff6de03 NA	431
3d16b64e NA	432	/* New symbol. */
3d16b64e NA	433	if (sym != NULL)
1ff6de03	434	{
3d16b64e NA	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. */
1ff6de03	452
3d16b64e NA	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)));
1ff6de03 NA	457	}
1ff6de03 NA	458	}
094e34f2	459	#else
3d16b64e NA	460	int
3d16b64e NA	461	ldelf_emit_ctf_early (void)
094e34f2 NA	462	{
	463	return 0;
	464	}
	465
3d16b64e NA	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)
094e34f2 NA	474	{}
094e34f2 NA	475	#endif