[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 bfd_boolean
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 bfd_boolean
link_order_scan (lang_statement_union_type *u,
		 lang_output_section_statement_type *os)
{
  asection *s;
  bfd_boolean 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;

  /* The only way we should get matching LMAs is when the first of 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 bfd_boolean
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 (bfd_boolean need_layout)
{
  int tries = 10;
  static bfd_boolean 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;

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