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

/* ldctor.c -- constructor support routines
   Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 1998
   Free Software Foundation, Inc.
   By Steve Chamberlain <sac@cygnus.com>
   
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 RH	1	/* ldctor.c -- constructor support routines
	2	Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 1998
	3	Free Software Foundation, Inc.
	4	By Steve Chamberlain <sac@cygnus.com>
	5
	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	{
89	einfo (_("%P%X: Different relocs used in set %s\n"), h->root.string);
90	return;
91	}
92
93	/* Don't permit a set to be constructed from different object
94	file formats. The same reloc may have different results. We
95	actually could sometimes handle this, but the case is
96	unlikely to ever arise. Sometimes constructor symbols are in
97	unusual sections, such as the absolute section--this appears
98	to be the case in Linux a.out--and in such cases we just
99	assume everything is OK. */
100	if (p->elements != NULL
101	&& section->owner != NULL
102	&& p->elements->section->owner != NULL
103	&& strcmp (bfd_get_target (section->owner),
104	bfd_get_target (p->elements->section->owner)) != 0)
105	{
106	einfo (_("%P%X: Different object file formats composing set %s\n"),
107	h->root.string);
108	return;
109	}
110	}
111
112	e = (struct set_element *) xmalloc (sizeof (struct set_element));
113	e->next = NULL;
114	e->name = name;
115	e->section = section;
116	e->value = value;
117
118	for (epp = &p->elements; epp != NULL; epp = &(epp)->next)
119	;
120	*epp = e;
121
122	++p->count;
123	}
124
125	/* Get the priority of a g++ global constructor or destructor from the
126	symbol name. */
127
128	static int
129	ctor_prio (name)
130	const char *name;
131	{
132	/* The name will look something like _GLOBAL_$I$65535$test02__Fv.
133	There might be extra leading underscores, and the $ characters
134	might be something else. The I might be a D. */
135
136	while (*name == '_')
137	++name;
138
139	if (strncmp (name, "GLOBAL_", sizeof "GLOBAL_" - 1) != 0)
140	return -1;
141
142	name += sizeof "GLOBAL_" - 1;
143
144	if (name[0] != name[2])
145	return -1;
146	if (name[1] != 'I' && name[1] != 'D')
147	return -1;
148	if (! isdigit ((unsigned char) name[3]))
149	return -1;
150
151	return atoi (name + 3);
152	}
153
154	/* This function is used to sort constructor elements by priority. It
155	is called via qsort. */
156
157	static int
158	ctor_cmp (p1, p2)
159	const PTR p1;
160	const PTR p2;
161	{
162	const struct set_element pe1 = (const struct set_element ) p1;
163	const struct set_element pe2 = (const struct set_element ) p2;
164	const char *n1;
165	const char *n2;
166	int prio1;
167	int prio2;
168
169	n1 = (*pe1)->name;
170	if (n1 == NULL)
171	n1 = "";
172	n2 = (*pe2)->name;
173	if (n2 == NULL)
174	n2 = "";
175
176	/* We need to sort in reverse order by priority. When two
177	constructors have the same priority, we should maintain their
178	current relative position. */
179
180	prio1 = ctor_prio (n1);
181	prio2 = ctor_prio (n2);
182
183	/* We sort in reverse order because that is what g++ expects. */
184	if (prio1 < prio2)
185	return 1;
186	else if (prio1 > prio2)
187	return -1;
188
189	/* Force a stable sort. */
190
191	if (pe1 < pe2)
192	return -1;
193	else if (pe1 > pe2)
194	return 1;
195	else
196	return 0;
197	}
198
199	/* This function is called after the first phase of the link and
200	before the second phase. At this point all set information has
201	been gathered. We now put the statements to build the sets
202	themselves into constructor_list. */
203
204	void
205	ldctor_build_sets ()
206	{
207	static boolean called;
208	lang_statement_list_type *old;
209	boolean header_printed;
210	struct set_info *p;
211
212	/* The emulation code may call us directly, but we only want to do
213	this once. */
214	if (called)
215	return;
216	called = true;
217
218	if (constructors_sorted)
219	{
220	for (p = sets; p != NULL; p = p->next)
221	{
222	int c, i;
223	struct set_element *e;
224	struct set_element **array;
225
226	if (p->elements == NULL)
227	continue;
228
229	c = 0;
230	for (e = p->elements; e != NULL; e = e->next)
231	++c;
232
233	array = (struct set_element *) xmalloc (c sizeof *array);
234
235	i = 0;
236	for (e = p->elements; e != NULL; e = e->next)
237	{
238	array[i] = e;
239	++i;
240	}
241
242	qsort (array, c, sizeof *array, ctor_cmp);
243
244	e = array[0];
245	p->elements = e;
246	for (i = 0; i < c - 1; i++)
247	array[i]->next = array[i + 1];
248	array[i]->next = NULL;
249
250	free (array);
251	}
252	}
253
254	old = stat_ptr;
255	stat_ptr = &constructor_list;
256
257	lang_list_init (stat_ptr);
258
259	header_printed = false;
260	for (p = sets; p != (struct set_info *) NULL; p = p->next)
261	{
262	struct set_element *e;
263	reloc_howto_type *howto;
264	int reloc_size, size;
265
266	/* If the symbol is defined, we may have been invoked from
267	collect, and the sets may already have been built, so we do
268	not do anything. */
269	if (p->h->type == bfd_link_hash_defined
270	\|\| p->h->type == bfd_link_hash_defweak)
271	continue;
272
273	/* For each set we build:
274	set:
275	.long number_of_elements
276	.long element0
277	...
278	.long elementN
279	.long 0
280	except that we use the right size instead of .long. When
281	generating relocateable output, we generate relocs instead of
282	addresses. */
283	howto = bfd_reloc_type_lookup (output_bfd, p->reloc);
284	if (howto == (reloc_howto_type *) NULL)
285	{
286	if (link_info.relocateable)
287	{
288	einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
289	bfd_get_target (output_bfd),
290	bfd_get_reloc_code_name (p->reloc),
291	p->h->root.string);
292	continue;
293	}
294
295	/* If this is not a relocateable link, all we need is the
296	size, which we can get from the input BFD. */
297	if (p->elements->section->owner != NULL)
298	howto = bfd_reloc_type_lookup (p->elements->section->owner,
299	p->reloc);
300	if (howto == NULL)
301	{
302	einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
303	bfd_get_target (p->elements->section->owner),
304	bfd_get_reloc_code_name (p->reloc),
305	p->h->root.string);
306	continue;
307	}
308	}
309
310	reloc_size = bfd_get_reloc_size (howto);
311	switch (reloc_size)
312	{
313	case 1: size = BYTE; break;
314	case 2: size = SHORT; break;
315	case 4: size = LONG; break;
316	case 8:
317	if (howto->complain_on_overflow == complain_overflow_signed)
318	size = SQUAD;
319	else
320	size = QUAD;
321	break;
322	default:
323	einfo (_("%P%X: Unsupported size %d for set %s\n"),
324	bfd_get_reloc_size (howto), p->h->root.string);
325	size = LONG;
326	break;
327	}
328
329	lang_add_assignment (exp_assop ('=', ".",
330	exp_unop (ALIGN_K,
331	exp_intop (reloc_size))));
332	lang_add_assignment (exp_assop ('=', p->h->root.string,
333	exp_nameop (NAME, ".")));
334	lang_add_data (size, exp_intop ((bfd_vma) p->count));
335
336	for (e = p->elements; e != (struct set_element *) 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 (link_info.relocateable)
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	stat_ptr = old;
383	}