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

/* ldctor.c -- constructor support routines
   Copyright (C) 1991-2016 Free Software Foundation, Inc.
   By Steve Chamberlain <sac@cygnus.com>

   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 "safe-ctype.h"

#include "ld.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldmisc.h"
#include <ldgram.h>
#include "ldmain.h"
#include "ldctor.h"

/* The list of statements needed to handle constructors.  These are
   invoked by the command CONSTRUCTORS in the linker script.  */
lang_statement_list_type constructor_list;

/* Whether the constructors should be sorted.  Note that this is
   global for the entire link; we assume that there is only a single
   CONSTRUCTORS command in the linker script.  */
bfd_boolean constructors_sorted;

/* The sets we have seen.  */
struct set_info *sets;

/* Add an entry to a set.  H is the entry in the linker hash table.
   RELOC is the relocation to use for an entry in the set.  SECTION
   and VALUE are the value to add.  This is called during the first
   phase of the link, when we are still gathering symbols together.
   We just record the information now.  The ldctor_build_sets
   function will construct the sets.  */

void
ldctor_add_set_entry (struct bfd_link_hash_entry *h,
		      bfd_reloc_code_real_type reloc,
		      const char *name,
		      asection *section,
		      bfd_vma value)
{
  struct set_info *p;
  struct set_element *e;
  struct set_element **epp;

  for (p = sets; p != NULL; p = p->next)
    if (p->h == h)
      break;

  if (p == NULL)
    {
      p = (struct set_info *) xmalloc (sizeof (struct set_info));
      p->next = sets;
      sets = p;
      p->h = h;
      p->reloc = reloc;
      p->count = 0;
      p->elements = NULL;
    }
  else
    {
      if (p->reloc != reloc)
	{
	  einfo (_("%P%X: Different relocs used in set %s\n"),
		 h->root.string);
	  return;
	}

      /* Don't permit a set to be constructed from different object
	 file formats.  The same reloc may have different results.  We
	 actually could sometimes handle this, but the case is
	 unlikely to ever arise.  Sometimes constructor symbols are in
	 unusual sections, such as the absolute section--this appears
	 to be the case in Linux a.out--and in such cases we just
	 assume everything is OK.  */
      if (p->elements != NULL
	  && section->owner != NULL
	  && p->elements->section->owner != NULL
	  && strcmp (bfd_get_target (section->owner),
		     bfd_get_target (p->elements->section->owner)) != 0)
	{
	  einfo (_("%P%X: Different object file formats composing set %s\n"),
		 h->root.string);
	  return;
	}
    }

  e = (struct set_element *) xmalloc (sizeof (struct set_element));
  e->next = NULL;
  e->name = name;
  e->section = section;
  e->value = value;

  for (epp = &p->elements; *epp != NULL; epp = &(*epp)->next)
    ;
  *epp = e;

  ++p->count;
}

/* Get the priority of a g++ global constructor or destructor from the
   symbol name.  */

static int
ctor_prio (const char *name)
{
  /* The name will look something like _GLOBAL_$I$65535$test02__Fv.
     There might be extra leading underscores, and the $ characters
     might be something else.  The I might be a D.  */

  while (*name == '_')
    ++name;

  if (!CONST_STRNEQ (name, "GLOBAL_"))
    return -1;

  name += sizeof "GLOBAL_" - 1;

  if (name[0] != name[2])
    return -1;
  if (name[1] != 'I' && name[1] != 'D')
    return -1;
  if (!ISDIGIT (name[3]))
    return -1;

  return atoi (name + 3);
}

/* This function is used to sort constructor elements by priority.  It
   is called via qsort.  */

static int
ctor_cmp (const void *p1, const void *p2)
{
  const struct set_element *const *pe1
    = (const struct set_element *const *) p1;
  const struct set_element *const *pe2
    = (const struct set_element *const *) p2;
  const char *n1;
  const char *n2;
  int prio1;
  int prio2;

  n1 = (*pe1)->name;
  if (n1 == NULL)
    n1 = "";
  n2 = (*pe2)->name;
  if (n2 == NULL)
    n2 = "";

  /* We need to sort in reverse order by priority.  When two
     constructors have the same priority, we should maintain their
     current relative position.  */

  prio1 = ctor_prio (n1);
  prio2 = ctor_prio (n2);

  /* We sort in reverse order because that is what g++ expects.  */
  if (prio1 < prio2)
    return 1;
  else if (prio1 > prio2)
    return -1;

  /* Force a stable sort.  */

  if (pe1 < pe2)
    return -1;
  else if (pe1 > pe2)
    return 1;
  else
    return 0;
}

/* This function is called after the first phase of the link and
   before the second phase.  At this point all set information has
   been gathered.  We now put the statements to build the sets
   themselves into constructor_list.  */

void
ldctor_build_sets (void)
{
  static bfd_boolean called;
  bfd_boolean header_printed;
  struct set_info *p;

  /* The emulation code may call us directly, but we only want to do
     this once.  */
  if (called)
    return;
  called = TRUE;

  if (constructors_sorted)
    {
      for (p = sets; p != NULL; p = p->next)
	{
	  int c, i;
	  struct set_element *e;
	  struct set_element **array;

	  if (p->elements == NULL)
	    continue;

	  c = 0;
	  for (e = p->elements; e != NULL; e = e->next)
	    ++c;

	  array = (struct set_element **) xmalloc (c * sizeof *array);

	  i = 0;
	  for (e = p->elements; e != NULL; e = e->next)
	    {
	      array[i] = e;
	      ++i;
	    }

	  qsort (array, c, sizeof *array, ctor_cmp);

	  e = array[0];
	  p->elements = e;
	  for (i = 0; i < c - 1; i++)
	    array[i]->next = array[i + 1];
	  array[i]->next = NULL;

	  free (array);
	}
    }

  lang_list_init (&constructor_list);
  push_stat_ptr (&constructor_list);

  header_printed = FALSE;
  for (p = sets; p != NULL; p = p->next)
    {
      struct set_element *e;
      reloc_howto_type *howto;
      int reloc_size, size;

      /* If the symbol is defined, we may have been invoked from
	 collect, and the sets may already have been built, so we do
	 not do anything.  */
      if (p->h->type == bfd_link_hash_defined
	  || p->h->type == bfd_link_hash_defweak)
	continue;

      /* For each set we build:
	   set:
	     .long number_of_elements
	     .long element0
	     ...
	     .long elementN
	     .long 0
	 except that we use the right size instead of .long.  When
	 generating relocatable output, we generate relocs instead of
	 addresses.  */
      howto = bfd_reloc_type_lookup (link_info.output_bfd, p->reloc);
      if (howto == NULL)
	{
	  if (bfd_link_relocatable (&link_info))
	    {
	      einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
		     bfd_get_target (link_info.output_bfd),
		     bfd_get_reloc_code_name (p->reloc),
		     p->h->root.string);
	      continue;
	    }

	  /* If this is not a relocatable link, all we need is the
	     size, which we can get from the input BFD.  */
	  if (p->elements->section->owner != NULL)
	    howto = bfd_reloc_type_lookup (p->elements->section->owner,
					   p->reloc);
	  if (howto == NULL)
	    {
	      /* See PR 20911 for a reproducer.  */
	      if (p->elements->section->owner == NULL)
		einfo (_("%P%X: Special section %s does not support reloc %s for set %s\n"),
		       bfd_get_section_name (link_info.output_bfd, p->elements->section),
		       bfd_get_reloc_code_name (p->reloc),
		       p->h->root.string);
	      else
		einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
		       bfd_get_target (p->elements->section->owner),
		       bfd_get_reloc_code_name (p->reloc),
		       p->h->root.string);
	      continue;
	    }
	}

      reloc_size = bfd_get_reloc_size (howto);
      switch (reloc_size)
	{
	case 1: size = BYTE; break;
	case 2: size = SHORT; break;
	case 4: size = LONG; break;
	case 8:
	  if (howto->complain_on_overflow == complain_overflow_signed)
	    size = SQUAD;
	  else
	    size = QUAD;
	  break;
	default:
	  einfo (_("%P%X: Unsupported size %d for set %s\n"),
		 bfd_get_reloc_size (howto), p->h->root.string);
	  size = LONG;
	  break;
	}

      lang_add_assignment (exp_assign (".",
				       exp_unop (ALIGN_K,
						 exp_intop (reloc_size)),
				       FALSE));
      lang_add_assignment (exp_assign (p->h->root.string,
				       exp_nameop (NAME, "."),
				       FALSE));
      lang_add_data (size, exp_intop (p->count));

      for (e = p->elements; e != NULL; e = e->next)
	{
	  if (config.map_file != NULL)
	    {
	      int len;

	      if (!header_printed)
		{
		  minfo (_("\nSet                 Symbol\n\n"));
		  header_printed = TRUE;
		}

	      minfo ("%s", p->h->root.string);
	      len = strlen (p->h->root.string);

	      if (len >= 19)
		{
		  print_nl ();
		  len = 0;
		}
	      while (len < 20)
		{
		  print_space ();
		  ++len;
		}

	      if (e->name != NULL)
		minfo ("%T\n", e->name);
	      else
		minfo ("%G\n", e->section->owner, e->section, e->value);
	    }

	  /* Need SEC_KEEP for --gc-sections.  */
	  if (!bfd_is_abs_section (e->section))
	    e->section->flags |= SEC_KEEP;

	  if (bfd_link_relocatable (&link_info))
	    lang_add_reloc (p->reloc, howto, e->section, e->name,
			    exp_intop (e->value));
	  else
	    lang_add_data (size, exp_relop (e->section, e->value));
	}

      lang_add_data (size, exp_intop (0));
    }

  pop_stat_ptr ();
}
Commit	Line	Data
	1	/* ldctor.c -- constructor support routines
	2	Copyright (C) 1991-2016 Free Software Foundation, Inc.
	3	By Steve Chamberlain <sac@cygnus.com>
	4
	5	This file is part of the GNU Binutils.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	20	MA 02110-1301, USA. */
	21
	22	#include "sysdep.h"
	23	#include "bfd.h"
	24	#include "bfdlink.h"
	25	#include "safe-ctype.h"
	26
	27	#include "ld.h"
	28	#include "ldexp.h"
	29	#include "ldlang.h"
	30	#include "ldmisc.h"
	31	#include <ldgram.h>
	32	#include "ldmain.h"
	33	#include "ldctor.h"
	34
	35	/* The list of statements needed to handle constructors. These are
	36	invoked by the command CONSTRUCTORS in the linker script. */
	37	lang_statement_list_type constructor_list;
	38
	39	/* Whether the constructors should be sorted. Note that this is
	40	global for the entire link; we assume that there is only a single
	41	CONSTRUCTORS command in the linker script. */
	42	bfd_boolean constructors_sorted;
	43
	44	/* The sets we have seen. */
	45	struct set_info *sets;
	46
	47	/* Add an entry to a set. H is the entry in the linker hash table.
	48	RELOC is the relocation to use for an entry in the set. SECTION
	49	and VALUE are the value to add. This is called during the first
	50	phase of the link, when we are still gathering symbols together.
	51	We just record the information now. The ldctor_build_sets
	52	function will construct the sets. */
	53
	54	void
	55	ldctor_add_set_entry (struct bfd_link_hash_entry *h,
	56	bfd_reloc_code_real_type reloc,
	57	const char *name,
	58	asection *section,
	59	bfd_vma value)
	60	{
	61	struct set_info *p;
	62	struct set_element *e;
	63	struct set_element **epp;
	64
	65	for (p = sets; p != NULL; p = p->next)
	66	if (p->h == h)
	67	break;
	68
	69	if (p == NULL)
	70	{
	71	p = (struct set_info *) xmalloc (sizeof (struct set_info));
	72	p->next = sets;
	73	sets = p;
	74	p->h = h;
	75	p->reloc = reloc;
	76	p->count = 0;
	77	p->elements = NULL;
	78	}
	79	else
	80	{
	81	if (p->reloc != reloc)
	82	{
	83	einfo (_("%P%X: Different relocs used in set %s\n"),
	84	h->root.string);
	85	return;
	86	}
	87
	88	/* Don't permit a set to be constructed from different object
	89	file formats. The same reloc may have different results. We
	90	actually could sometimes handle this, but the case is
	91	unlikely to ever arise. Sometimes constructor symbols are in
	92	unusual sections, such as the absolute section--this appears
	93	to be the case in Linux a.out--and in such cases we just
	94	assume everything is OK. */
	95	if (p->elements != NULL
	96	&& section->owner != NULL
	97	&& p->elements->section->owner != NULL
	98	&& strcmp (bfd_get_target (section->owner),
	99	bfd_get_target (p->elements->section->owner)) != 0)
	100	{
	101	einfo (_("%P%X: Different object file formats composing set %s\n"),
	102	h->root.string);
	103	return;
	104	}
	105	}
	106
	107	e = (struct set_element *) xmalloc (sizeof (struct set_element));
	108	e->next = NULL;
	109	e->name = name;
	110	e->section = section;
	111	e->value = value;
	112
	113	for (epp = &p->elements; epp != NULL; epp = &(epp)->next)
	114	;
	115	*epp = e;
	116
	117	++p->count;
	118	}
	119
	120	/* Get the priority of a g++ global constructor or destructor from the
	121	symbol name. */
	122
	123	static int
	124	ctor_prio (const char *name)
	125	{
	126	/* The name will look something like _GLOBAL_$I$65535$test02__Fv.
	127	There might be extra leading underscores, and the $ characters
	128	might be something else. The I might be a D. */
	129
	130	while (*name == '_')
	131	++name;
	132
	133	if (!CONST_STRNEQ (name, "GLOBAL_"))
	134	return -1;
	135
	136	name += sizeof "GLOBAL_" - 1;
	137
	138	if (name[0] != name[2])
	139	return -1;
	140	if (name[1] != 'I' && name[1] != 'D')
	141	return -1;
	142	if (!ISDIGIT (name[3]))
	143	return -1;
	144
	145	return atoi (name + 3);
	146	}
	147
	148	/* This function is used to sort constructor elements by priority. It
	149	is called via qsort. */
	150
	151	static int
	152	ctor_cmp (const void p1, const void p2)
	153	{
	154	const struct set_element const pe1
	155	= (const struct set_element const ) p1;
	156	const struct set_element const pe2
	157	= (const struct set_element const ) p2;
	158	const char *n1;
	159	const char *n2;
	160	int prio1;
	161	int prio2;
	162
	163	n1 = (*pe1)->name;
	164	if (n1 == NULL)
	165	n1 = "";
	166	n2 = (*pe2)->name;
	167	if (n2 == NULL)
	168	n2 = "";
	169
	170	/* We need to sort in reverse order by priority. When two
	171	constructors have the same priority, we should maintain their
	172	current relative position. */
	173
	174	prio1 = ctor_prio (n1);
	175	prio2 = ctor_prio (n2);
	176
	177	/* We sort in reverse order because that is what g++ expects. */
	178	if (prio1 < prio2)
	179	return 1;
	180	else if (prio1 > prio2)
	181	return -1;
	182
	183	/* Force a stable sort. */
	184
	185	if (pe1 < pe2)
	186	return -1;
	187	else if (pe1 > pe2)
	188	return 1;
	189	else
	190	return 0;
	191	}
	192
	193	/* This function is called after the first phase of the link and
	194	before the second phase. At this point all set information has
	195	been gathered. We now put the statements to build the sets
	196	themselves into constructor_list. */
	197
	198	void
	199	ldctor_build_sets (void)
	200	{
	201	static bfd_boolean called;
	202	bfd_boolean header_printed;
	203	struct set_info *p;
	204
	205	/* The emulation code may call us directly, but we only want to do
	206	this once. */
	207	if (called)
	208	return;
	209	called = TRUE;
	210
	211	if (constructors_sorted)
	212	{
	213	for (p = sets; p != NULL; p = p->next)
	214	{
	215	int c, i;
	216	struct set_element *e;
	217	struct set_element **array;
	218
	219	if (p->elements == NULL)
	220	continue;
	221
	222	c = 0;
	223	for (e = p->elements; e != NULL; e = e->next)
	224	++c;
	225
	226	array = (struct set_element *) xmalloc (c sizeof *array);
	227
	228	i = 0;
	229	for (e = p->elements; e != NULL; e = e->next)
	230	{
	231	array[i] = e;
	232	++i;
	233	}
	234
	235	qsort (array, c, sizeof *array, ctor_cmp);
	236
	237	e = array[0];
	238	p->elements = e;
	239	for (i = 0; i < c - 1; i++)
	240	array[i]->next = array[i + 1];
	241	array[i]->next = NULL;
	242
	243	free (array);
	244	}
	245	}
	246
	247	lang_list_init (&constructor_list);
	248	push_stat_ptr (&constructor_list);
	249
	250	header_printed = FALSE;
	251	for (p = sets; p != NULL; p = p->next)
	252	{
	253	struct set_element *e;
	254	reloc_howto_type *howto;
	255	int reloc_size, size;
	256
	257	/* If the symbol is defined, we may have been invoked from
	258	collect, and the sets may already have been built, so we do
	259	not do anything. */
	260	if (p->h->type == bfd_link_hash_defined
	261	\|\| p->h->type == bfd_link_hash_defweak)
	262	continue;
	263
	264	/* For each set we build:
	265	set:
	266	.long number_of_elements
	267	.long element0
	268	...
	269	.long elementN
	270	.long 0
	271	except that we use the right size instead of .long. When
	272	generating relocatable output, we generate relocs instead of
	273	addresses. */
	274	howto = bfd_reloc_type_lookup (link_info.output_bfd, p->reloc);
	275	if (howto == NULL)
	276	{
	277	if (bfd_link_relocatable (&link_info))
	278	{
	279	einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
	280	bfd_get_target (link_info.output_bfd),
	281	bfd_get_reloc_code_name (p->reloc),
	282	p->h->root.string);
	283	continue;
	284	}
	285
	286	/* If this is not a relocatable link, all we need is the
	287	size, which we can get from the input BFD. */
	288	if (p->elements->section->owner != NULL)
	289	howto = bfd_reloc_type_lookup (p->elements->section->owner,
	290	p->reloc);
	291	if (howto == NULL)
	292	{
	293	/* See PR 20911 for a reproducer. */
	294	if (p->elements->section->owner == NULL)
	295	einfo (_("%P%X: Special section %s does not support reloc %s for set %s\n"),
	296	bfd_get_section_name (link_info.output_bfd, p->elements->section),
	297	bfd_get_reloc_code_name (p->reloc),
	298	p->h->root.string);
	299	else
	300	einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
	301	bfd_get_target (p->elements->section->owner),
	302	bfd_get_reloc_code_name (p->reloc),
	303	p->h->root.string);
	304	continue;
	305	}
	306	}
	307
	308	reloc_size = bfd_get_reloc_size (howto);
	309	switch (reloc_size)
	310	{
	311	case 1: size = BYTE; break;
	312	case 2: size = SHORT; break;
	313	case 4: size = LONG; break;
	314	case 8:
	315	if (howto->complain_on_overflow == complain_overflow_signed)
	316	size = SQUAD;
	317	else
	318	size = QUAD;
	319	break;
	320	default:
	321	einfo (_("%P%X: Unsupported size %d for set %s\n"),
	322	bfd_get_reloc_size (howto), p->h->root.string);
	323	size = LONG;
	324	break;
	325	}
	326
	327	lang_add_assignment (exp_assign (".",
	328	exp_unop (ALIGN_K,
	329	exp_intop (reloc_size)),
	330	FALSE));
	331	lang_add_assignment (exp_assign (p->h->root.string,
	332	exp_nameop (NAME, "."),
	333	FALSE));
	334	lang_add_data (size, exp_intop (p->count));
	335
	336	for (e = p->elements; e != NULL; e = e->next)
	337	{
	338	if (config.map_file != NULL)
	339	{
	340	int len;
	341
	342	if (!header_printed)
	343	{
	344	minfo (_("\nSet Symbol\n\n"));
	345	header_printed = TRUE;
	346	}
	347
	348	minfo ("%s", p->h->root.string);
	349	len = strlen (p->h->root.string);
	350
	351	if (len >= 19)
	352	{
	353	print_nl ();
	354	len = 0;
	355	}
	356	while (len < 20)
	357	{
	358	print_space ();
	359	++len;
	360	}
	361
	362	if (e->name != NULL)
	363	minfo ("%T\n", e->name);
	364	else
	365	minfo ("%G\n", e->section->owner, e->section, e->value);
	366	}
	367
	368	/* Need SEC_KEEP for --gc-sections. */
	369	if (!bfd_is_abs_section (e->section))
	370	e->section->flags \|= SEC_KEEP;
	371
	372	if (bfd_link_relocatable (&link_info))
	373	lang_add_reloc (p->reloc, howto, e->section, e->name,
	374	exp_intop (e->value));
	375	else
	376	lang_add_data (size, exp_relop (e->section, e->value));
	377	}
	378
	379	lang_add_data (size, exp_intop (0));
	380	}
	381
	382	pop_stat_ptr ();
	383	}