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

/* ldctor.c -- constructor support routines
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   2002, 2003, 2004, 2006, 2007, 2008, 2009
   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 = 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 = 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 = p1;
  const struct set_element * const *pe2 = 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 = 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 (link_info.relocatable)
	    {
	      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)
	    {
	      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_assop ('=', ".",
				      exp_unop (ALIGN_K,
						exp_intop (reloc_size))));
      lang_add_assignment (exp_assop ('=', p->h->root.string,
				      exp_nameop (NAME, ".")));
      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 (link_info.relocatable)
	    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
252b5132	1	/* ldctor.c -- constructor support routines
b34976b6	2	Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
bde18da4 AM	3	2002, 2003, 2004, 2006, 2007, 2008, 2009
bde18da4 AM	4	Free Software Foundation, Inc.
252b5132	5	By Steve Chamberlain <sac@cygnus.com>
4de2d33d	6
f96b4a7b	7	This file is part of the GNU Binutils.
252b5132	8
f96b4a7b NC	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 3 of the License, or
	12	(at your option) any later version.
252b5132	13
f96b4a7b NC	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
252b5132	18
f96b4a7b NC	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	22	MA 02110-1301, USA. */
252b5132	23
252b5132	24	#include "sysdep.h"
3db64b00	25	#include "bfd.h"
252b5132	26	#include "bfdlink.h"
3882b010	27	#include "safe-ctype.h"
252b5132 RH	28
	29	#include "ld.h"
	30	#include "ldexp.h"
	31	#include "ldlang.h"
	32	#include "ldmisc.h"
df2a7313	33	#include <ldgram.h>
252b5132 RH	34	#include "ldmain.h"
	35	#include "ldctor.h"
	36
252b5132 RH	37	/* The list of statements needed to handle constructors. These are
	38	invoked by the command CONSTRUCTORS in the linker script. */
	39	lang_statement_list_type constructor_list;
	40
	41	/* Whether the constructors should be sorted. Note that this is
	42	global for the entire link; we assume that there is only a single
	43	CONSTRUCTORS command in the linker script. */
b34976b6	44	bfd_boolean constructors_sorted;
252b5132 RH	45
	46	/* The sets we have seen. */
	47	struct set_info *sets;
	48
	49	/* Add an entry to a set. H is the entry in the linker hash table.
	50	RELOC is the relocation to use for an entry in the set. SECTION
	51	and VALUE are the value to add. This is called during the first
	52	phase of the link, when we are still gathering symbols together.
95c148b4	53	We just record the information now. The ldctor_build_sets
252b5132 RH	54	function will construct the sets. */
	55
	56	void
1579bae1 AM	57	ldctor_add_set_entry (struct bfd_link_hash_entry *h,
	58	bfd_reloc_code_real_type reloc,
	59	const char *name,
	60	asection *section,
	61	bfd_vma value)
252b5132 RH	62	{
	63	struct set_info *p;
	64	struct set_element *e;
	65	struct set_element **epp;
	66
1579bae1	67	for (p = sets; p != NULL; p = p->next)
252b5132 RH	68	if (p->h == h)
	69	break;
	70
1579bae1	71	if (p == NULL)
252b5132	72	{
1579bae1	73	p = xmalloc (sizeof (struct set_info));
252b5132 RH	74	p->next = sets;
	75	sets = p;
	76	p->h = h;
	77	p->reloc = reloc;
	78	p->count = 0;
	79	p->elements = NULL;
	80	}
	81	else
	82	{
	83	if (p->reloc != reloc)
	84	{
4de2d33d KH	85	einfo (_("%P%X: Different relocs used in set %s\n"),
4de2d33d KH	86	h->root.string);
252b5132 RH	87	return;
	88	}
	89
	90	/* Don't permit a set to be constructed from different object
	91	file formats. The same reloc may have different results. We
	92	actually could sometimes handle this, but the case is
	93	unlikely to ever arise. Sometimes constructor symbols are in
	94	unusual sections, such as the absolute section--this appears
	95	to be the case in Linux a.out--and in such cases we just
	96	assume everything is OK. */
	97	if (p->elements != NULL
	98	&& section->owner != NULL
	99	&& p->elements->section->owner != NULL
	100	&& strcmp (bfd_get_target (section->owner),
	101	bfd_get_target (p->elements->section->owner)) != 0)
	102	{
	103	einfo (_("%P%X: Different object file formats composing set %s\n"),
	104	h->root.string);
	105	return;
	106	}
	107	}
	108
1579bae1	109	e = xmalloc (sizeof (struct set_element));
252b5132 RH	110	e->next = NULL;
	111	e->name = name;
	112	e->section = section;
	113	e->value = value;
	114
	115	for (epp = &p->elements; epp != NULL; epp = &(epp)->next)
	116	;
	117	*epp = e;
	118
	119	++p->count;
	120	}
	121
	122	/* Get the priority of a g++ global constructor or destructor from the
	123	symbol name. */
	124
	125	static int
1579bae1	126	ctor_prio (const char *name)
252b5132 RH	127	{
	128	/* The name will look something like _GLOBAL_$I$65535$test02__Fv.
	129	There might be extra leading underscores, and the $ characters
	130	might be something else. The I might be a D. */
	131
	132	while (*name == '_')
	133	++name;
	134
0112cd26	135	if (! CONST_STRNEQ (name, "GLOBAL_"))
252b5132 RH	136	return -1;
	137
	138	name += sizeof "GLOBAL_" - 1;
	139
	140	if (name[0] != name[2])
	141	return -1;
	142	if (name[1] != 'I' && name[1] != 'D')
	143	return -1;
3882b010	144	if (! ISDIGIT (name[3]))
252b5132 RH	145	return -1;
	146
	147	return atoi (name + 3);
	148	}
	149
	150	/* This function is used to sort constructor elements by priority. It
	151	is called via qsort. */
	152
	153	static int
1579bae1	154	ctor_cmp (const void p1, const void p2)
252b5132	155	{
1579bae1 AM	156	const struct set_element * const *pe1 = p1;
1579bae1 AM	157	const struct set_element * const *pe2 = p2;
252b5132 RH	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
1579bae1	199	ldctor_build_sets (void)
252b5132	200	{
b34976b6	201	static bfd_boolean called;
b34976b6	202	bfd_boolean header_printed;
252b5132 RH	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;
b34976b6	209	called = TRUE;
252b5132 RH	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
1579bae1	226	array = xmalloc (c * sizeof *array);
252b5132 RH	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
bde18da4 AM	247	lang_list_init (&constructor_list);
bde18da4 AM	248	push_stat_ptr (&constructor_list);
252b5132	249
b34976b6	250	header_printed = FALSE;
1579bae1	251	for (p = sets; p != NULL; p = p->next)
252b5132 RH	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
1049f94e	272	generating relocatable output, we generate relocs instead of
252b5132	273	addresses. */
f13a99db	274	howto = bfd_reloc_type_lookup (link_info.output_bfd, p->reloc);
1579bae1	275	if (howto == NULL)
252b5132	276	{
1049f94e	277	if (link_info.relocatable)
252b5132 RH	278	{
252b5132 RH	279	einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
f13a99db	280	bfd_get_target (link_info.output_bfd),
252b5132 RH	281	bfd_get_reloc_code_name (p->reloc),
	282	p->h->root.string);
	283	continue;
	284	}
	285
1049f94e	286	/* If this is not a relocatable link, all we need is the
252b5132 RH	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	einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
	294	bfd_get_target (p->elements->section->owner),
	295	bfd_get_reloc_code_name (p->reloc),
	296	p->h->root.string);
	297	continue;
	298	}
	299	}
	300
	301	reloc_size = bfd_get_reloc_size (howto);
	302	switch (reloc_size)
	303	{
	304	case 1: size = BYTE; break;
	305	case 2: size = SHORT; break;
	306	case 4: size = LONG; break;
	307	case 8:
	308	if (howto->complain_on_overflow == complain_overflow_signed)
	309	size = SQUAD;
	310	else
	311	size = QUAD;
	312	break;
	313	default:
	314	einfo (_("%P%X: Unsupported size %d for set %s\n"),
	315	bfd_get_reloc_size (howto), p->h->root.string);
	316	size = LONG;
	317	break;
	318	}
	319
	320	lang_add_assignment (exp_assop ('=', ".",
	321	exp_unop (ALIGN_K,
	322	exp_intop (reloc_size))));
	323	lang_add_assignment (exp_assop ('=', p->h->root.string,
	324	exp_nameop (NAME, ".")));
1579bae1	325	lang_add_data (size, exp_intop (p->count));
252b5132	326
1579bae1	327	for (e = p->elements; e != NULL; e = e->next)
252b5132 RH	328	{
	329	if (config.map_file != NULL)
	330	{
	331	int len;
	332
	333	if (! header_printed)
	334	{
	335	minfo (_("\nSet Symbol\n\n"));
b34976b6	336	header_printed = TRUE;
252b5132 RH	337	}
	338
	339	minfo ("%s", p->h->root.string);
	340	len = strlen (p->h->root.string);
	341
	342	if (len >= 19)
	343	{
	344	print_nl ();
	345	len = 0;
	346	}
	347	while (len < 20)
	348	{
	349	print_space ();
	350	++len;
	351	}
	352
	353	if (e->name != NULL)
	354	minfo ("%T\n", e->name);
	355	else
	356	minfo ("%G\n", e->section->owner, e->section, e->value);
	357	}
	358
4de2d33d	359	/* Need SEC_KEEP for --gc-sections. */
252b5132 RH	360	if (! bfd_is_abs_section (e->section))
	361	e->section->flags \|= SEC_KEEP;
	362
1049f94e	363	if (link_info.relocatable)
252b5132 RH	364	lang_add_reloc (p->reloc, howto, e->section, e->name,
	365	exp_intop (e->value));
	366	else
	367	lang_add_data (size, exp_relop (e->section, e->value));
	368	}
	369
	370	lang_add_data (size, exp_intop (0));
	371	}
	372
bde18da4	373	pop_stat_ptr ();
252b5132	374	}