[binutils.git] / ld / ldctor.c

/* ldctor.c -- constructor support routines
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   Free Software Foundation, Inc.
   By Steve Chamberlain <[email protected]>

This file is part of GLD, the Gnu Linker.

GLD 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 2, or (at your option)
any later version.

GLD 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 GLD; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"

#include <ctype.h>

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

static int ctor_prio PARAMS ((const char *));
static int ctor_cmp PARAMS ((const PTR, const PTR));

/* 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.  */
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_find_constructors
   function will construct the sets.  */

void
ldctor_add_set_entry (h, reloc, name, section, value)
     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 != (struct set_info *) NULL; p = p->next)
    if (p->h == h)
      break;

  if (p == (struct set_info *) 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 (name)
     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 (strncmp (name, "GLOBAL_", sizeof "GLOBAL_" - 1) != 0)
    return -1;

  name += sizeof "GLOBAL_" - 1;

  if (name[0] != name[2])
    return -1;
  if (name[1] != 'I' && name[1] != 'D')
    return -1;
  if (! isdigit ((unsigned char) 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 (p1, p2)
     const PTR p1;
     const PTR p2;
{
  const struct set_element **pe1 = (const struct set_element **) p1;
  const struct set_element **pe2 = (const struct set_element **) 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 ()
{
  static boolean called;
  lang_statement_list_type *old;
  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);
	}
    }

  old = stat_ptr;
  stat_ptr = &constructor_list;

  lang_list_init (stat_ptr);

  header_printed = false;
  for (p = sets; p != (struct set_info *) 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 relocateable output, we generate relocs instead of
	 addresses.  */
      howto = bfd_reloc_type_lookup (output_bfd, p->reloc);
      if (howto == (reloc_howto_type *) NULL)
	{
	  if (link_info.relocateable)
	    {
	      einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
		     bfd_get_target (output_bfd),
		     bfd_get_reloc_code_name (p->reloc),
		     p->h->root.string);
	      continue;
	    }

	  /* If this is not a relocateable 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 ((bfd_vma) p->count));

      for (e = p->elements; e != (struct set_element *) 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.relocateable)
	    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));
    }

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