1/* ldctor.c -- constructor support routines
2   Copyright (C) 1991-2017 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.  */
37lang_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.  */
42bfd_boolean constructors_sorted;
43
44/* The sets we have seen.  */
45struct 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
54void
55ldctor_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
123static int
124ctor_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
151static int
152ctor_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
198void
199ldctor_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}
384