Automatic date update in version.in
[binutils-gdb.git] / ld / ldwrite.c
blobf7d379a64c15a2421a99782c5ad5234511a47e22
1 /* ldwrite.c -- write out the linked file
2 Copyright (C) 1991-2022 Free Software Foundation, Inc.
3 Written 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 "bfd.h"
24 #include "bfdlink.h"
25 #include "libiberty.h"
26 #include "ctf-api.h"
27 #include "safe-ctype.h"
29 #include "ld.h"
30 #include "ldexp.h"
31 #include "ldlang.h"
32 #include "ldwrite.h"
33 #include "ldmisc.h"
34 #include <ldgram.h>
35 #include "ldmain.h"
37 /* Build link_order structures for the BFD linker. */
39 static void
40 build_link_order (lang_statement_union_type *statement)
42 switch (statement->header.type)
44 case lang_data_statement_enum:
46 asection *output_section;
47 struct bfd_link_order *link_order;
48 bfd_vma value;
50 output_section = statement->data_statement.output_section;
51 ASSERT (output_section->owner == link_info.output_bfd);
53 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
54 || ((output_section->flags & SEC_LOAD) != 0
55 && (output_section->flags & SEC_THREAD_LOCAL))))
56 break;
58 link_order = bfd_new_link_order (link_info.output_bfd, output_section);
59 if (link_order == NULL)
60 einfo (_("%F%P: bfd_new_link_order failed\n"));
62 link_order->type = bfd_data_link_order;
63 link_order->offset = statement->data_statement.output_offset;
64 link_order->u.data.contents = (bfd_byte *) xmalloc (QUAD_SIZE);
66 value = statement->data_statement.value;
68 /* By convention, the bfd_put routines for an unknown
69 endianness are big endian, so we must swap here if the
70 input is little endian. */
71 if (!bfd_big_endian (link_info.output_bfd)
72 && !bfd_little_endian (link_info.output_bfd)
73 && !link_info.big_endian)
75 bfd_byte buffer[8];
77 switch (statement->data_statement.type)
79 case QUAD:
80 case SQUAD:
81 if (sizeof (bfd_vma) >= QUAD_SIZE)
83 bfd_putl64 (value, buffer);
84 value = bfd_getb64 (buffer);
85 break;
87 /* Fall through. */
88 case LONG:
89 bfd_putl32 (value, buffer);
90 value = bfd_getb32 (buffer);
91 break;
92 case SHORT:
93 bfd_putl16 (value, buffer);
94 value = bfd_getb16 (buffer);
95 break;
96 case BYTE:
97 break;
98 default:
99 abort ();
103 ASSERT (output_section->owner == link_info.output_bfd);
104 switch (statement->data_statement.type)
106 case QUAD:
107 case SQUAD:
108 if (sizeof (bfd_vma) >= QUAD_SIZE)
109 bfd_put_64 (link_info.output_bfd, value,
110 link_order->u.data.contents);
111 else
113 bfd_vma high;
115 if (statement->data_statement.type == QUAD)
116 high = 0;
117 else if ((value & 0x80000000) == 0)
118 high = 0;
119 else
120 high = (bfd_vma) -1;
121 bfd_put_32 (link_info.output_bfd, high,
122 (link_order->u.data.contents
123 + (link_info.big_endian ? 0 : 4)));
124 bfd_put_32 (link_info.output_bfd, value,
125 (link_order->u.data.contents
126 + (link_info.big_endian ? 4 : 0)));
128 link_order->size = QUAD_SIZE;
129 break;
130 case LONG:
131 bfd_put_32 (link_info.output_bfd, value,
132 link_order->u.data.contents);
133 link_order->size = LONG_SIZE;
134 break;
135 case SHORT:
136 bfd_put_16 (link_info.output_bfd, value,
137 link_order->u.data.contents);
138 link_order->size = SHORT_SIZE;
139 break;
140 case BYTE:
141 bfd_put_8 (link_info.output_bfd, value,
142 link_order->u.data.contents);
143 link_order->size = BYTE_SIZE;
144 break;
145 default:
146 abort ();
148 link_order->u.data.size = link_order->size;
150 break;
152 case lang_reloc_statement_enum:
154 lang_reloc_statement_type *rs;
155 asection *output_section;
156 struct bfd_link_order *link_order;
158 rs = &statement->reloc_statement;
160 output_section = rs->output_section;
161 ASSERT (output_section->owner == link_info.output_bfd);
163 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
164 || ((output_section->flags & SEC_LOAD) != 0
165 && (output_section->flags & SEC_THREAD_LOCAL))))
166 break;
168 link_order = bfd_new_link_order (link_info.output_bfd, output_section);
169 if (link_order == NULL)
170 einfo (_("%F%P: bfd_new_link_order failed\n"));
172 link_order->offset = rs->output_offset;
173 link_order->size = bfd_get_reloc_size (rs->howto);
175 link_order->u.reloc.p = (struct bfd_link_order_reloc *)
176 xmalloc (sizeof (struct bfd_link_order_reloc));
178 link_order->u.reloc.p->reloc = rs->reloc;
179 link_order->u.reloc.p->addend = rs->addend_value;
181 if (rs->name == NULL)
183 link_order->type = bfd_section_reloc_link_order;
184 if (rs->section->owner == link_info.output_bfd)
185 link_order->u.reloc.p->u.section = rs->section;
186 else
188 link_order->u.reloc.p->u.section = rs->section->output_section;
189 link_order->u.reloc.p->addend += rs->section->output_offset;
192 else
194 link_order->type = bfd_symbol_reloc_link_order;
195 link_order->u.reloc.p->u.name = rs->name;
198 break;
200 case lang_input_section_enum:
202 /* Create a new link_order in the output section with this
203 attached */
204 asection *i = statement->input_section.section;
206 if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
207 && (i->flags & SEC_EXCLUDE) == 0)
209 asection *output_section = i->output_section;
210 struct bfd_link_order *link_order;
212 ASSERT (output_section->owner == link_info.output_bfd);
214 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
215 || ((output_section->flags & SEC_LOAD) != 0
216 && (output_section->flags & SEC_THREAD_LOCAL))))
217 break;
219 link_order = bfd_new_link_order (link_info.output_bfd,
220 output_section);
221 if (link_order == NULL)
222 einfo (_("%F%P: bfd_new_link_order failed\n"));
224 if ((i->flags & SEC_NEVER_LOAD) != 0
225 && (i->flags & SEC_DEBUGGING) == 0)
227 /* We've got a never load section inside one which is
228 going to be output, we'll change it into a fill. */
229 link_order->type = bfd_data_link_order;
230 link_order->u.data.contents = (unsigned char *) "";
231 link_order->u.data.size = 1;
233 else
235 link_order->type = bfd_indirect_link_order;
236 link_order->u.indirect.section = i;
237 ASSERT (i->output_section == output_section);
239 link_order->size = i->size;
240 link_order->offset = i->output_offset;
243 break;
245 case lang_padding_statement_enum:
246 /* Make a new link_order with the right filler */
248 asection *output_section;
249 struct bfd_link_order *link_order;
251 output_section = statement->padding_statement.output_section;
252 ASSERT (statement->padding_statement.output_section->owner
253 == link_info.output_bfd);
255 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
256 || ((output_section->flags & SEC_LOAD) != 0
257 && (output_section->flags & SEC_THREAD_LOCAL))))
258 break;
260 link_order = bfd_new_link_order (link_info.output_bfd,
261 output_section);
262 if (link_order == NULL)
263 einfo (_("%F%P: bfd_new_link_order failed\n"));
264 link_order->type = bfd_data_link_order;
265 link_order->size = statement->padding_statement.size;
266 link_order->offset = statement->padding_statement.output_offset;
267 link_order->u.data.contents = statement->padding_statement.fill->data;
268 link_order->u.data.size = statement->padding_statement.fill->size;
270 break;
272 default:
273 /* All the other ones fall through */
274 break;
278 /* Return true if NAME is the name of an unsplittable section. These
279 are the stabs strings, dwarf strings. */
281 static bool
282 unsplittable_name (const char *name)
284 if (startswith (name, ".stab"))
286 /* There are several stab like string sections. We pattern match on
287 ".stab...str" */
288 unsigned len = strlen (name);
289 if (strcmp (&name[len-3], "str") == 0)
290 return true;
292 else if (strcmp (name, "$GDB_STRINGS$") == 0)
293 return true;
294 return false;
297 /* Wander around the input sections, make sure that
298 we'll never try and create an output section with more relocs
299 than will fit.. Do this by always assuming the worst case, and
300 creating new output sections with all the right bits. */
301 #define TESTIT 1
302 static asection *
303 clone_section (bfd *abfd, asection *s, const char *name, int *count)
305 char *tname;
306 char *sname;
307 unsigned int len;
308 asection *n;
309 struct bfd_link_hash_entry *h;
311 /* Invent a section name from the section name and a dotted numeric
312 suffix. */
313 len = strlen (name);
314 tname = (char *) xmalloc (len + 1);
315 memcpy (tname, name, len + 1);
316 /* Remove a dotted number suffix, from a previous split link. */
317 while (len && ISDIGIT (tname[len-1]))
318 len--;
319 if (len > 1 && tname[len-1] == '.')
320 /* It was a dotted number. */
321 tname[len-1] = 0;
323 /* We want to use the whole of the original section name for the
324 split name, but coff can be restricted to 8 character names. */
325 if (bfd_family_coff (abfd) && strlen (tname) > 5)
327 /* Some section names cannot be truncated, as the name is
328 used to locate some other section. */
329 if (startswith (name, ".stab")
330 || strcmp (name, "$GDB_SYMBOLS$") == 0)
332 einfo (_ ("%F%P: cannot create split section name for %s\n"), name);
333 /* Silence gcc warnings. einfo exits, so we never reach here. */
334 return NULL;
336 tname[5] = 0;
339 if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL
340 || (n = bfd_make_section_anyway (abfd, sname)) == NULL
341 || (h = bfd_link_hash_lookup (link_info.hash,
342 sname, true, true, false)) == NULL)
344 einfo (_("%F%P: clone section failed: %E\n"));
345 /* Silence gcc warnings. einfo exits, so we never reach here. */
346 return NULL;
348 free (tname);
350 /* Set up section symbol. */
351 h->type = bfd_link_hash_defined;
352 h->u.def.value = 0;
353 h->u.def.section = n;
355 n->flags = s->flags;
356 n->vma = s->vma;
357 n->user_set_vma = s->user_set_vma;
358 n->lma = s->lma;
359 n->size = 0;
360 n->output_offset = s->output_offset;
361 n->output_section = n;
362 n->orelocation = 0;
363 n->reloc_count = 0;
364 n->alignment_power = s->alignment_power;
366 bfd_copy_private_section_data (abfd, s, abfd, n);
368 return n;
371 #if TESTING
372 static void
373 ds (asection *s)
375 struct bfd_link_order *l = s->map_head.link_order;
376 printf ("vma %x size %x\n", s->vma, s->size);
377 while (l)
379 if (l->type == bfd_indirect_link_order)
380 printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
381 else
382 printf (_("%8x something else\n"), l->offset);
383 l = l->next;
385 printf ("\n");
388 dump (char *s, asection *a1, asection *a2)
390 printf ("%s\n", s);
391 ds (a1);
392 ds (a2);
395 static void
396 sanity_check (bfd *abfd)
398 asection *s;
399 for (s = abfd->sections; s; s = s->next)
401 struct bfd_link_order *p;
402 bfd_vma prev = 0;
403 for (p = s->map_head.link_order; p; p = p->next)
405 if (p->offset > 100000)
406 abort ();
407 if (p->offset < prev)
408 abort ();
409 prev = p->offset;
413 #else
414 #define sanity_check(a)
415 #define dump(a, b, c)
416 #endif
418 static void
419 split_sections (bfd *abfd, struct bfd_link_info *info)
421 asection *original_sec;
422 int nsecs = abfd->section_count;
423 sanity_check (abfd);
424 /* Look through all the original sections. */
425 for (original_sec = abfd->sections;
426 original_sec && nsecs;
427 original_sec = original_sec->next, nsecs--)
429 int count = 0;
430 unsigned int lines = 0;
431 unsigned int relocs = 0;
432 bfd_size_type sec_size = 0;
433 struct bfd_link_order *l;
434 struct bfd_link_order *p;
435 bfd_vma vma = original_sec->vma;
436 asection *cursor = original_sec;
438 /* Count up the relocations and line entries to see if anything
439 would be too big to fit. Accumulate section size too. */
440 for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next)
442 unsigned int thislines = 0;
443 unsigned int thisrelocs = 0;
444 bfd_size_type thissize = 0;
445 if (p->type == bfd_indirect_link_order)
447 asection *sec;
449 sec = p->u.indirect.section;
451 if (info->strip == strip_none
452 || info->strip == strip_some)
453 thislines = sec->lineno_count;
455 if (bfd_link_relocatable (info))
456 thisrelocs = sec->reloc_count;
458 thissize = sec->size;
461 else if (bfd_link_relocatable (info)
462 && (p->type == bfd_section_reloc_link_order
463 || p->type == bfd_symbol_reloc_link_order))
464 thisrelocs++;
466 if (l != NULL
467 && (thisrelocs + relocs >= config.split_by_reloc
468 || thislines + lines >= config.split_by_reloc
469 || (thissize + sec_size >= config.split_by_file))
470 && !unsplittable_name (cursor->name))
472 /* Create a new section and put this link order and the
473 following link orders into it. */
474 bfd_vma shift_offset;
475 asection *n;
477 n = clone_section (abfd, cursor, original_sec->name, &count);
479 /* Attach the link orders to the new section and snip
480 them off from the old section. */
481 n->map_head.link_order = p;
482 n->map_tail.link_order = cursor->map_tail.link_order;
483 cursor->map_tail.link_order = l;
484 l->next = NULL;
485 l = p;
487 /* Change the size of the original section and
488 update the vma of the new one. */
490 dump ("before snip", cursor, n);
492 shift_offset = p->offset;
493 n->size = cursor->size - shift_offset;
494 cursor->size = shift_offset;
496 vma += shift_offset;
497 n->lma = n->vma = vma;
499 /* Run down the chain and change the output section to
500 the right one, update the offsets too. */
503 p->offset -= shift_offset;
504 if (p->type == bfd_indirect_link_order)
506 p->u.indirect.section->output_section = n;
507 p->u.indirect.section->output_offset = p->offset;
509 p = p->next;
511 while (p);
513 dump ("after snip", cursor, n);
514 cursor = n;
515 relocs = thisrelocs;
516 lines = thislines;
517 sec_size = thissize;
519 else
521 l = p;
522 relocs += thisrelocs;
523 lines += thislines;
524 sec_size += thissize;
528 sanity_check (abfd);
531 /* Call BFD to write out the linked file. */
533 void
534 ldwrite (void)
536 /* Reset error indicator, which can typically something like invalid
537 format from opening up the .o files. */
538 bfd_set_error (bfd_error_no_error);
539 lang_clear_os_map ();
540 lang_for_each_statement (build_link_order);
542 if (config.split_by_reloc != (unsigned) -1
543 || config.split_by_file != (bfd_size_type) -1)
544 split_sections (link_info.output_bfd, &link_info);
545 if (!bfd_final_link (link_info.output_bfd, &link_info))
547 /* If there was an error recorded, print it out. Otherwise assume
548 an appropriate error message like unknown symbol was printed
549 out. */
551 if (bfd_get_error () != bfd_error_no_error)
552 einfo (_("%F%P: final link failed: %E\n"));
553 else
554 xexit (1);