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