Automatic date update in version.in
[binutils-gdb.git] / ld / ldctor.c
blob02b928276bcff9168234fc2f62eb2c2e1a82b8fa
1 /* ldctor.c -- constructor support routines
2 Copyright (C) 1991-2024 Free Software Foundation, Inc.
3 By Steve Chamberlain <sac@cygnus.com>
5 This file is part of the GNU Binutils.
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.
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.
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. */
22 #include "sysdep.h"
23 #include "libiberty.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "safe-ctype.h"
27 #include "ctf-api.h"
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"
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;
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. */
44 bool constructors_sorted;
46 /* The sets we have seen. */
47 struct set_info *sets;
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.
53 We just record the information now. The ldctor_build_sets
54 function will construct the sets. */
56 void
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)
63 struct set_info *p;
64 struct set_element *e;
65 struct set_element **epp;
67 for (p = sets; p != NULL; p = p->next)
68 if (p->h == h)
69 break;
71 if (p == NULL)
73 p = (struct set_info *) xmalloc (sizeof (struct set_info));
74 p->next = sets;
75 sets = p;
76 p->h = h;
77 p->reloc = reloc;
78 p->count = 0;
79 p->elements = NULL;
81 else
83 if (p->reloc != reloc)
85 einfo (_("%X%P: different relocs used in set %s\n"),
86 h->root.string);
87 return;
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)
103 einfo (_("%X%P: different object file formats composing set %s\n"),
104 h->root.string);
105 return;
109 e = (struct set_element *) xmalloc (sizeof (struct set_element));
110 e->u.next = NULL;
111 e->name = name;
112 e->section = section;
113 e->value = value;
115 for (epp = &p->elements; *epp != NULL; epp = &(*epp)->u.next)
117 *epp = e;
119 ++p->count;
122 /* Get the priority of a g++ global constructor or destructor from the
123 symbol name. */
125 static int
126 ctor_prio (const char *name)
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. */
132 while (*name == '_')
133 ++name;
135 if (!startswith (name, "GLOBAL_"))
136 return -1;
138 name += sizeof "GLOBAL_" - 1;
140 if (name[0] != name[2])
141 return -1;
142 if (name[1] != 'I' && name[1] != 'D')
143 return -1;
144 if (!ISDIGIT (name[3]))
145 return -1;
147 return atoi (name + 3);
150 /* This function is used to sort constructor elements by priority. It
151 is called via qsort. */
153 static int
154 ctor_cmp (const void *p1, const void *p2)
156 const struct set_element *pe1 = *(const struct set_element **) p1;
157 const struct set_element *pe2 = *(const struct set_element **) p2;
158 const char *n1;
159 const char *n2;
160 int prio1;
161 int prio2;
163 n1 = pe1->name;
164 if (n1 == NULL)
165 n1 = "";
166 n2 = pe2->name;
167 if (n2 == NULL)
168 n2 = "";
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. */
174 prio1 = ctor_prio (n1);
175 prio2 = ctor_prio (n2);
177 /* We sort in reverse order because that is what g++ expects. */
178 if (prio1 < prio2)
179 return 1;
180 if (prio1 > prio2)
181 return -1;
183 /* Force a stable sort. */
184 if (pe1->u.idx < pe2->u.idx)
185 return -1;
186 if (pe1->u.idx > pe2->u.idx)
187 return 1;
188 return 0;
191 /* This function is called after the first phase of the link and
192 before the second phase. At this point all set information has
193 been gathered. We now put the statements to build the sets
194 themselves into constructor_list. */
196 void
197 ldctor_build_sets (void)
199 static bool called;
200 bool header_printed;
201 struct set_info *p;
203 /* The emulation code may call us directly, but we only want to do
204 this once. */
205 if (called)
206 return;
207 called = true;
209 if (constructors_sorted)
211 for (p = sets; p != NULL; p = p->next)
213 int c, i;
214 struct set_element *e, *enext;
215 struct set_element **array;
217 if (p->elements == NULL)
218 continue;
220 c = 0;
221 for (e = p->elements; e != NULL; e = e->u.next)
222 ++c;
224 array = (struct set_element **) xmalloc (c * sizeof *array);
226 i = 0;
227 for (e = p->elements; e != NULL; e = enext)
229 array[i] = e;
230 enext = e->u.next;
231 e->u.idx = i;
232 ++i;
235 qsort (array, c, sizeof *array, ctor_cmp);
237 e = array[0];
238 p->elements = e;
239 for (i = 0; i < c - 1; i++)
240 array[i]->u.next = array[i + 1];
241 array[i]->u.next = NULL;
243 free (array);
247 lang_list_init (&constructor_list);
248 push_stat_ptr (&constructor_list);
250 header_printed = false;
251 for (p = sets; p != NULL; p = p->next)
253 struct set_element *e;
254 reloc_howto_type *howto;
255 int reloc_size, size;
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;
264 /* For each set we build:
265 set:
266 .long number_of_elements
267 .long element0
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)
277 if (bfd_link_relocatable (&link_info))
279 einfo (_("%X%P: %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;
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)
293 /* See PR 20911 for a reproducer. */
294 if (p->elements->section->owner == NULL)
295 einfo (_("%X%P: special section %s does not support reloc %s for set %s\n"),
296 bfd_section_name (p->elements->section),
297 bfd_get_reloc_code_name (p->reloc),
298 p->h->root.string);
299 else
300 einfo (_("%X%P: %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;
308 reloc_size = bfd_get_reloc_size (howto);
309 switch (reloc_size)
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 (_("%X%P: unsupported size %d for set %s\n"),
322 bfd_get_reloc_size (howto), p->h->root.string);
323 size = LONG;
324 break;
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));
336 for (e = p->elements; e != NULL; e = e->u.next)
338 if (config.map_file != NULL)
340 int len;
342 if (!header_printed)
344 minfo (_("\nSet Symbol\n\n"));
345 header_printed = true;
348 minfo ("%s", p->h->root.string);
349 len = strlen (p->h->root.string);
351 if (len >= 19)
353 print_nl ();
354 len = 0;
356 print_spaces (20 - len);
358 if (e->name != NULL)
359 minfo ("%pT\n", e->name);
360 else
361 minfo ("%G\n", e->section->owner, e->section, e->value);
364 /* Need SEC_KEEP for --gc-sections. */
365 if (!bfd_is_abs_section (e->section))
366 e->section->flags |= SEC_KEEP;
368 if (bfd_link_relocatable (&link_info))
369 lang_add_reloc (p->reloc, howto, e->section, e->name,
370 exp_intop (e->value));
371 else
372 lang_add_data (size, exp_relop (e->section, e->value));
375 lang_add_data (size, exp_intop (0));
378 pop_stat_ptr ();