1 /* ldwrite.c -- write out the linked file
2 Copyright (C) 1991-2019 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. */
25 #include "libiberty.h"
27 #include "safe-ctype.h"
37 /* Build link_order structures for the BFD linker. */
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
;
49 bfd_boolean big_endian
= FALSE
;
51 output_section
= statement
->data_statement
.output_section
;
52 ASSERT (output_section
->owner
== link_info
.output_bfd
);
54 if (!((output_section
->flags
& SEC_HAS_CONTENTS
) != 0
55 || ((output_section
->flags
& SEC_LOAD
) != 0
56 && (output_section
->flags
& SEC_THREAD_LOCAL
))))
59 link_order
= bfd_new_link_order (link_info
.output_bfd
, output_section
);
60 if (link_order
== NULL
)
61 einfo (_("%F%P: bfd_new_link_order failed\n"));
63 link_order
->type
= bfd_data_link_order
;
64 link_order
->offset
= statement
->data_statement
.output_offset
;
65 link_order
->u
.data
.contents
= (bfd_byte
*) xmalloc (QUAD_SIZE
);
67 value
= statement
->data_statement
.value
;
69 /* If the endianness of the output BFD is not known, then we
70 base the endianness of the data on the first input file.
71 By convention, the bfd_put routines for an unknown
72 endianness are big endian, so we must swap here if the
73 input file is little endian. */
74 if (bfd_big_endian (link_info
.output_bfd
))
76 else if (bfd_little_endian (link_info
.output_bfd
))
83 if (command_line
.endian
== ENDIAN_BIG
)
85 else if (command_line
.endian
== ENDIAN_LITTLE
)
90 else if (command_line
.endian
== ENDIAN_UNSET
)
94 LANG_FOR_EACH_INPUT_STATEMENT (s
)
96 if (s
->the_bfd
!= NULL
)
98 if (bfd_little_endian (s
->the_bfd
))
113 switch (statement
->data_statement
.type
)
117 if (sizeof (bfd_vma
) >= QUAD_SIZE
)
119 bfd_putl64 (value
, buffer
);
120 value
= bfd_getb64 (buffer
);
125 bfd_putl32 (value
, buffer
);
126 value
= bfd_getb32 (buffer
);
129 bfd_putl16 (value
, buffer
);
130 value
= bfd_getb16 (buffer
);
140 ASSERT (output_section
->owner
== link_info
.output_bfd
);
141 switch (statement
->data_statement
.type
)
145 if (sizeof (bfd_vma
) >= QUAD_SIZE
)
146 bfd_put_64 (link_info
.output_bfd
, value
,
147 link_order
->u
.data
.contents
);
152 if (statement
->data_statement
.type
== QUAD
)
154 else if ((value
& 0x80000000) == 0)
158 bfd_put_32 (link_info
.output_bfd
, high
,
159 (link_order
->u
.data
.contents
160 + (big_endian
? 0 : 4)));
161 bfd_put_32 (link_info
.output_bfd
, value
,
162 (link_order
->u
.data
.contents
163 + (big_endian
? 4 : 0)));
165 link_order
->size
= QUAD_SIZE
;
168 bfd_put_32 (link_info
.output_bfd
, value
,
169 link_order
->u
.data
.contents
);
170 link_order
->size
= LONG_SIZE
;
173 bfd_put_16 (link_info
.output_bfd
, value
,
174 link_order
->u
.data
.contents
);
175 link_order
->size
= SHORT_SIZE
;
178 bfd_put_8 (link_info
.output_bfd
, value
,
179 link_order
->u
.data
.contents
);
180 link_order
->size
= BYTE_SIZE
;
185 link_order
->u
.data
.size
= link_order
->size
;
189 case lang_reloc_statement_enum
:
191 lang_reloc_statement_type
*rs
;
192 asection
*output_section
;
193 struct bfd_link_order
*link_order
;
195 rs
= &statement
->reloc_statement
;
197 output_section
= rs
->output_section
;
198 ASSERT (output_section
->owner
== link_info
.output_bfd
);
200 if (!((output_section
->flags
& SEC_HAS_CONTENTS
) != 0
201 || ((output_section
->flags
& SEC_LOAD
) != 0
202 && (output_section
->flags
& SEC_THREAD_LOCAL
))))
205 link_order
= bfd_new_link_order (link_info
.output_bfd
, output_section
);
206 if (link_order
== NULL
)
207 einfo (_("%F%P: bfd_new_link_order failed\n"));
209 link_order
->offset
= rs
->output_offset
;
210 link_order
->size
= bfd_get_reloc_size (rs
->howto
);
212 link_order
->u
.reloc
.p
= (struct bfd_link_order_reloc
*)
213 xmalloc (sizeof (struct bfd_link_order_reloc
));
215 link_order
->u
.reloc
.p
->reloc
= rs
->reloc
;
216 link_order
->u
.reloc
.p
->addend
= rs
->addend_value
;
218 if (rs
->name
== NULL
)
220 link_order
->type
= bfd_section_reloc_link_order
;
221 if (rs
->section
->owner
== link_info
.output_bfd
)
222 link_order
->u
.reloc
.p
->u
.section
= rs
->section
;
225 link_order
->u
.reloc
.p
->u
.section
= rs
->section
->output_section
;
226 link_order
->u
.reloc
.p
->addend
+= rs
->section
->output_offset
;
231 link_order
->type
= bfd_symbol_reloc_link_order
;
232 link_order
->u
.reloc
.p
->u
.name
= rs
->name
;
237 case lang_input_section_enum
:
239 /* Create a new link_order in the output section with this
241 asection
*i
= statement
->input_section
.section
;
243 if (i
->sec_info_type
!= SEC_INFO_TYPE_JUST_SYMS
244 && (i
->flags
& SEC_EXCLUDE
) == 0)
246 asection
*output_section
= i
->output_section
;
247 struct bfd_link_order
*link_order
;
249 ASSERT (output_section
->owner
== link_info
.output_bfd
);
251 if (!((output_section
->flags
& SEC_HAS_CONTENTS
) != 0
252 || ((output_section
->flags
& SEC_LOAD
) != 0
253 && (output_section
->flags
& SEC_THREAD_LOCAL
))))
256 link_order
= bfd_new_link_order (link_info
.output_bfd
,
258 if (link_order
== NULL
)
259 einfo (_("%F%P: bfd_new_link_order failed\n"));
261 if ((i
->flags
& SEC_NEVER_LOAD
) != 0
262 && (i
->flags
& SEC_DEBUGGING
) == 0)
264 /* We've got a never load section inside one which is
265 going to be output, we'll change it into a fill. */
266 link_order
->type
= bfd_data_link_order
;
267 link_order
->u
.data
.contents
= (unsigned char *) "";
268 link_order
->u
.data
.size
= 1;
272 link_order
->type
= bfd_indirect_link_order
;
273 link_order
->u
.indirect
.section
= i
;
274 ASSERT (i
->output_section
== output_section
);
276 link_order
->size
= i
->size
;
277 link_order
->offset
= i
->output_offset
;
282 case lang_padding_statement_enum
:
283 /* Make a new link_order with the right filler */
285 asection
*output_section
;
286 struct bfd_link_order
*link_order
;
288 output_section
= statement
->padding_statement
.output_section
;
289 ASSERT (statement
->padding_statement
.output_section
->owner
290 == link_info
.output_bfd
);
292 if (!((output_section
->flags
& SEC_HAS_CONTENTS
) != 0
293 || ((output_section
->flags
& SEC_LOAD
) != 0
294 && (output_section
->flags
& SEC_THREAD_LOCAL
))))
297 link_order
= bfd_new_link_order (link_info
.output_bfd
,
299 if (link_order
== NULL
)
300 einfo (_("%F%P: bfd_new_link_order failed\n"));
301 link_order
->type
= bfd_data_link_order
;
302 link_order
->size
= statement
->padding_statement
.size
;
303 link_order
->offset
= statement
->padding_statement
.output_offset
;
304 link_order
->u
.data
.contents
= statement
->padding_statement
.fill
->data
;
305 link_order
->u
.data
.size
= statement
->padding_statement
.fill
->size
;
310 /* All the other ones fall through */
315 /* Return true if NAME is the name of an unsplittable section. These
316 are the stabs strings, dwarf strings. */
319 unsplittable_name (const char *name
)
321 if (CONST_STRNEQ (name
, ".stab"))
323 /* There are several stab like string sections. We pattern match on
325 unsigned len
= strlen (name
);
326 if (strcmp (&name
[len
-3], "str") == 0)
329 else if (strcmp (name
, "$GDB_STRINGS$") == 0)
334 /* Wander around the input sections, make sure that
335 we'll never try and create an output section with more relocs
336 than will fit.. Do this by always assuming the worst case, and
337 creating new output sections with all the right bits. */
340 clone_section (bfd
*abfd
, asection
*s
, const char *name
, int *count
)
346 struct bfd_link_hash_entry
*h
;
348 /* Invent a section name from the section name and a dotted numeric
351 tname
= (char *) xmalloc (len
+ 1);
352 memcpy (tname
, name
, len
+ 1);
353 /* Remove a dotted number suffix, from a previous split link. */
354 while (len
&& ISDIGIT (tname
[len
-1]))
356 if (len
> 1 && tname
[len
-1] == '.')
357 /* It was a dotted number. */
360 /* We want to use the whole of the original section name for the
361 split name, but coff can be restricted to 8 character names. */
362 if (bfd_family_coff (abfd
) && strlen (tname
) > 5)
364 /* Some section names cannot be truncated, as the name is
365 used to locate some other section. */
366 if (CONST_STRNEQ (name
, ".stab")
367 || strcmp (name
, "$GDB_SYMBOLS$") == 0)
369 einfo (_ ("%F%P: cannot create split section name for %s\n"), name
);
370 /* Silence gcc warnings. einfo exits, so we never reach here. */
376 if ((sname
= bfd_get_unique_section_name (abfd
, tname
, count
)) == NULL
377 || (n
= bfd_make_section_anyway (abfd
, sname
)) == NULL
378 || (h
= bfd_link_hash_lookup (link_info
.hash
,
379 sname
, TRUE
, TRUE
, FALSE
)) == NULL
)
381 einfo (_("%F%P: clone section failed: %E\n"));
382 /* Silence gcc warnings. einfo exits, so we never reach here. */
387 /* Set up section symbol. */
388 h
->type
= bfd_link_hash_defined
;
390 h
->u
.def
.section
= n
;
394 n
->user_set_vma
= s
->user_set_vma
;
397 n
->output_offset
= s
->output_offset
;
398 n
->output_section
= n
;
401 n
->alignment_power
= s
->alignment_power
;
403 bfd_copy_private_section_data (abfd
, s
, abfd
, n
);
412 struct bfd_link_order
*l
= s
->map_head
.link_order
;
413 printf ("vma %x size %x\n", s
->vma
, s
->size
);
416 if (l
->type
== bfd_indirect_link_order
)
417 printf ("%8x %s\n", l
->offset
, l
->u
.indirect
.section
->owner
->filename
);
419 printf (_("%8x something else\n"), l
->offset
);
425 dump (char *s
, asection
*a1
, asection
*a2
)
433 sanity_check (bfd
*abfd
)
436 for (s
= abfd
->sections
; s
; s
= s
->next
)
438 struct bfd_link_order
*p
;
440 for (p
= s
->map_head
.link_order
; p
; p
= p
->next
)
442 if (p
->offset
> 100000)
444 if (p
->offset
< prev
)
451 #define sanity_check(a)
452 #define dump(a, b, c)
456 split_sections (bfd
*abfd
, struct bfd_link_info
*info
)
458 asection
*original_sec
;
459 int nsecs
= abfd
->section_count
;
461 /* Look through all the original sections. */
462 for (original_sec
= abfd
->sections
;
463 original_sec
&& nsecs
;
464 original_sec
= original_sec
->next
, nsecs
--)
467 unsigned int lines
= 0;
468 unsigned int relocs
= 0;
469 bfd_size_type sec_size
= 0;
470 struct bfd_link_order
*l
;
471 struct bfd_link_order
*p
;
472 bfd_vma vma
= original_sec
->vma
;
473 asection
*cursor
= original_sec
;
475 /* Count up the relocations and line entries to see if anything
476 would be too big to fit. Accumulate section size too. */
477 for (l
= NULL
, p
= cursor
->map_head
.link_order
; p
!= NULL
; p
= l
->next
)
479 unsigned int thislines
= 0;
480 unsigned int thisrelocs
= 0;
481 bfd_size_type thissize
= 0;
482 if (p
->type
== bfd_indirect_link_order
)
486 sec
= p
->u
.indirect
.section
;
488 if (info
->strip
== strip_none
489 || info
->strip
== strip_some
)
490 thislines
= sec
->lineno_count
;
492 if (bfd_link_relocatable (info
))
493 thisrelocs
= sec
->reloc_count
;
495 thissize
= sec
->size
;
498 else if (bfd_link_relocatable (info
)
499 && (p
->type
== bfd_section_reloc_link_order
500 || p
->type
== bfd_symbol_reloc_link_order
))
504 && (thisrelocs
+ relocs
>= config
.split_by_reloc
505 || thislines
+ lines
>= config
.split_by_reloc
506 || (thissize
+ sec_size
>= config
.split_by_file
))
507 && !unsplittable_name (cursor
->name
))
509 /* Create a new section and put this link order and the
510 following link orders into it. */
511 bfd_vma shift_offset
;
514 n
= clone_section (abfd
, cursor
, original_sec
->name
, &count
);
516 /* Attach the link orders to the new section and snip
517 them off from the old section. */
518 n
->map_head
.link_order
= p
;
519 n
->map_tail
.link_order
= cursor
->map_tail
.link_order
;
520 cursor
->map_tail
.link_order
= l
;
524 /* Change the size of the original section and
525 update the vma of the new one. */
527 dump ("before snip", cursor
, n
);
529 shift_offset
= p
->offset
;
530 n
->size
= cursor
->size
- shift_offset
;
531 cursor
->size
= shift_offset
;
534 n
->lma
= n
->vma
= vma
;
536 /* Run down the chain and change the output section to
537 the right one, update the offsets too. */
540 p
->offset
-= shift_offset
;
541 if (p
->type
== bfd_indirect_link_order
)
543 p
->u
.indirect
.section
->output_section
= n
;
544 p
->u
.indirect
.section
->output_offset
= p
->offset
;
550 dump ("after snip", cursor
, n
);
559 relocs
+= thisrelocs
;
561 sec_size
+= thissize
;
568 /* Call BFD to write out the linked file. */
573 /* Reset error indicator, which can typically something like invalid
574 format from opening up the .o files. */
575 bfd_set_error (bfd_error_no_error
);
576 lang_clear_os_map ();
577 lang_for_each_statement (build_link_order
);
579 if (config
.split_by_reloc
!= (unsigned) -1
580 || config
.split_by_file
!= (bfd_size_type
) -1)
581 split_sections (link_info
.output_bfd
, &link_info
);
582 if (!bfd_final_link (link_info
.output_bfd
, &link_info
))
584 /* If there was an error recorded, print it out. Otherwise assume
585 an appropriate error message like unknown symbol was printed
588 if (bfd_get_error () != bfd_error_no_error
)
589 einfo (_("%F%P: final link failed: %E\n"));