1 /* ldwrite.c -- write out the linked file
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 Written by Steve Chamberlain sac@cygnus.com
6 This file is part of the GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 #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 link_order
= bfd_new_link_order (link_info
.output_bfd
, output_section
);
55 if (link_order
== NULL
)
56 einfo (_("%P%F: bfd_new_link_order failed\n"));
58 link_order
->type
= bfd_data_link_order
;
59 link_order
->offset
= statement
->data_statement
.output_offset
;
60 link_order
->u
.data
.contents
= xmalloc (QUAD_SIZE
);
62 value
= statement
->data_statement
.value
;
64 /* If the endianness of the output BFD is not known, then we
65 base the endianness of the data on the first input file.
66 By convention, the bfd_put routines for an unknown
67 endianness are big endian, so we must swap here if the
68 input file is little endian. */
69 if (bfd_big_endian (link_info
.output_bfd
))
71 else if (bfd_little_endian (link_info
.output_bfd
))
78 if (command_line
.endian
== ENDIAN_BIG
)
80 else if (command_line
.endian
== ENDIAN_LITTLE
)
85 else if (command_line
.endian
== ENDIAN_UNSET
)
89 LANG_FOR_EACH_INPUT_STATEMENT (s
)
91 if (s
->the_bfd
!= NULL
)
93 if (bfd_little_endian (s
->the_bfd
))
108 switch (statement
->data_statement
.type
)
112 if (sizeof (bfd_vma
) >= QUAD_SIZE
)
114 bfd_putl64 (value
, buffer
);
115 value
= bfd_getb64 (buffer
);
120 bfd_putl32 (value
, buffer
);
121 value
= bfd_getb32 (buffer
);
124 bfd_putl16 (value
, buffer
);
125 value
= bfd_getb16 (buffer
);
135 ASSERT (output_section
->owner
== link_info
.output_bfd
);
136 switch (statement
->data_statement
.type
)
140 if (sizeof (bfd_vma
) >= QUAD_SIZE
)
141 bfd_put_64 (link_info
.output_bfd
, value
,
142 link_order
->u
.data
.contents
);
147 if (statement
->data_statement
.type
== QUAD
)
149 else if ((value
& 0x80000000) == 0)
153 bfd_put_32 (link_info
.output_bfd
, high
,
154 (link_order
->u
.data
.contents
155 + (big_endian
? 0 : 4)));
156 bfd_put_32 (link_info
.output_bfd
, value
,
157 (link_order
->u
.data
.contents
158 + (big_endian
? 4 : 0)));
160 link_order
->size
= QUAD_SIZE
;
163 bfd_put_32 (link_info
.output_bfd
, value
,
164 link_order
->u
.data
.contents
);
165 link_order
->size
= LONG_SIZE
;
168 bfd_put_16 (link_info
.output_bfd
, value
,
169 link_order
->u
.data
.contents
);
170 link_order
->size
= SHORT_SIZE
;
173 bfd_put_8 (link_info
.output_bfd
, value
,
174 link_order
->u
.data
.contents
);
175 link_order
->size
= BYTE_SIZE
;
183 case lang_reloc_statement_enum
:
185 lang_reloc_statement_type
*rs
;
186 asection
*output_section
;
187 struct bfd_link_order
*link_order
;
189 rs
= &statement
->reloc_statement
;
191 output_section
= rs
->output_section
;
192 ASSERT (output_section
->owner
== link_info
.output_bfd
);
194 link_order
= bfd_new_link_order (link_info
.output_bfd
, output_section
);
195 if (link_order
== NULL
)
196 einfo (_("%P%F: bfd_new_link_order failed\n"));
198 link_order
->offset
= rs
->output_offset
;
199 link_order
->size
= bfd_get_reloc_size (rs
->howto
);
201 link_order
->u
.reloc
.p
= xmalloc (sizeof (struct bfd_link_order_reloc
));
203 link_order
->u
.reloc
.p
->reloc
= rs
->reloc
;
204 link_order
->u
.reloc
.p
->addend
= rs
->addend_value
;
206 if (rs
->name
== NULL
)
208 link_order
->type
= bfd_section_reloc_link_order
;
209 if (rs
->section
->owner
== link_info
.output_bfd
)
210 link_order
->u
.reloc
.p
->u
.section
= rs
->section
;
213 link_order
->u
.reloc
.p
->u
.section
= rs
->section
->output_section
;
214 link_order
->u
.reloc
.p
->addend
+= rs
->section
->output_offset
;
219 link_order
->type
= bfd_symbol_reloc_link_order
;
220 link_order
->u
.reloc
.p
->u
.name
= rs
->name
;
225 case lang_input_section_enum
:
227 /* Create a new link_order in the output section with this
229 asection
*i
= statement
->input_section
.section
;
231 if (!((lang_input_statement_type
*) i
->owner
->usrdata
)->just_syms_flag
232 && (i
->flags
& SEC_EXCLUDE
) == 0)
234 asection
*output_section
= i
->output_section
;
236 ASSERT (output_section
->owner
== link_info
.output_bfd
);
238 if ((output_section
->flags
& SEC_HAS_CONTENTS
) != 0
239 || ((output_section
->flags
& SEC_LOAD
) != 0
240 && (output_section
->flags
& SEC_THREAD_LOCAL
)))
242 struct bfd_link_order
*link_order
;
244 link_order
= bfd_new_link_order (link_info
.output_bfd
,
247 if (i
->flags
& SEC_NEVER_LOAD
)
249 /* We've got a never load section inside one which
250 is going to be output, we'll change it into a
252 link_order
->type
= bfd_data_link_order
;
253 link_order
->u
.data
.contents
= (unsigned char *) "";
254 link_order
->u
.data
.size
= 1;
258 link_order
->type
= bfd_indirect_link_order
;
259 link_order
->u
.indirect
.section
= i
;
260 ASSERT (i
->output_section
== output_section
);
262 link_order
->size
= i
->size
;
263 link_order
->offset
= i
->output_offset
;
269 case lang_padding_statement_enum
:
270 /* Make a new link_order with the right filler */
272 asection
*output_section
;
273 struct bfd_link_order
*link_order
;
275 output_section
= statement
->padding_statement
.output_section
;
276 ASSERT (statement
->padding_statement
.output_section
->owner
277 == link_info
.output_bfd
);
278 if (((output_section
->flags
& SEC_HAS_CONTENTS
) != 0
279 || ((output_section
->flags
& SEC_LOAD
) != 0
280 && (output_section
->flags
& SEC_THREAD_LOCAL
)))
281 && (output_section
->flags
& SEC_NEVER_LOAD
) == 0)
283 link_order
= bfd_new_link_order (link_info
.output_bfd
,
285 link_order
->type
= bfd_data_link_order
;
286 link_order
->size
= statement
->padding_statement
.size
;
287 link_order
->offset
= statement
->padding_statement
.output_offset
;
288 link_order
->u
.data
.contents
= statement
->padding_statement
.fill
->data
;
289 link_order
->u
.data
.size
= statement
->padding_statement
.fill
->size
;
295 /* All the other ones fall through */
300 /* Return true if NAME is the name of an unsplittable section. These
301 are the stabs strings, dwarf strings. */
304 unsplittable_name (const char *name
)
306 if (CONST_STRNEQ (name
, ".stab"))
308 /* There are several stab like string sections. We pattern match on
310 unsigned len
= strlen (name
);
311 if (strcmp (&name
[len
-3], "str") == 0)
314 else if (strcmp (name
, "$GDB_STRINGS$") == 0)
319 /* Wander around the input sections, make sure that
320 we'll never try and create an output section with more relocs
321 than will fit.. Do this by always assuming the worst case, and
322 creating new output sections with all the right bits. */
325 clone_section (bfd
*abfd
, asection
*s
, const char *name
, int *count
)
331 struct bfd_link_hash_entry
*h
;
333 /* Invent a section name from the section name and a dotted numeric
336 tname
= xmalloc (len
+ 1);
337 memcpy (tname
, name
, len
+ 1);
338 /* Remove a dotted number suffix, from a previous split link. */
339 while (len
&& ISDIGIT (tname
[len
-1]))
341 if (len
> 1 && tname
[len
-1] == '.')
342 /* It was a dotted number. */
345 /* We want to use the whole of the original section name for the
346 split name, but coff can be restricted to 8 character names. */
347 if (bfd_family_coff (abfd
) && strlen (tname
) > 5)
349 /* Some section names cannot be truncated, as the name is
350 used to locate some other section. */
351 if (CONST_STRNEQ (name
, ".stab")
352 || strcmp (name
, "$GDB_SYMBOLS$") == 0)
354 einfo (_ ("%F%P: cannot create split section name for %s\n"), name
);
355 /* Silence gcc warnings. einfo exits, so we never reach here. */
361 if ((sname
= bfd_get_unique_section_name (abfd
, tname
, count
)) == NULL
362 || (n
= bfd_make_section_anyway (abfd
, sname
)) == NULL
363 || (h
= bfd_link_hash_lookup (link_info
.hash
,
364 sname
, TRUE
, TRUE
, FALSE
)) == NULL
)
366 einfo (_("%F%P: clone section failed: %E\n"));
367 /* Silence gcc warnings. einfo exits, so we never reach here. */
372 /* Set up section symbol. */
373 h
->type
= bfd_link_hash_defined
;
375 h
->u
.def
.section
= n
;
379 n
->user_set_vma
= s
->user_set_vma
;
382 n
->output_offset
= s
->output_offset
;
383 n
->output_section
= n
;
386 n
->alignment_power
= s
->alignment_power
;
394 struct bfd_link_order
*l
= s
->map_head
.link_order
;
395 printf ("vma %x size %x\n", s
->vma
, s
->size
);
398 if (l
->type
== bfd_indirect_link_order
)
400 printf ("%8x %s\n", l
->offset
, l
->u
.indirect
.section
->owner
->filename
);
404 printf (_("%8x something else\n"), l
->offset
);
411 dump (char *s
, asection
*a1
, asection
*a2
)
419 sanity_check (bfd
*abfd
)
422 for (s
= abfd
->sections
; s
; s
= s
->next
)
424 struct bfd_link_order
*p
;
426 for (p
= s
->map_head
.link_order
; p
; p
= p
->next
)
428 if (p
->offset
> 100000)
430 if (p
->offset
< prev
)
437 #define sanity_check(a)
438 #define dump(a, b, c)
442 split_sections (bfd
*abfd
, struct bfd_link_info
*info
)
444 asection
*original_sec
;
445 int nsecs
= abfd
->section_count
;
447 /* Look through all the original sections. */
448 for (original_sec
= abfd
->sections
;
449 original_sec
&& nsecs
;
450 original_sec
= original_sec
->next
, nsecs
--)
453 unsigned int lines
= 0;
454 unsigned int relocs
= 0;
455 bfd_size_type sec_size
= 0;
456 struct bfd_link_order
*l
;
457 struct bfd_link_order
*p
;
458 bfd_vma vma
= original_sec
->vma
;
459 asection
*cursor
= original_sec
;
461 /* Count up the relocations and line entries to see if anything
462 would be too big to fit. Accumulate section size too. */
463 for (l
= NULL
, p
= cursor
->map_head
.link_order
; p
!= NULL
; p
= l
->next
)
465 unsigned int thislines
= 0;
466 unsigned int thisrelocs
= 0;
467 bfd_size_type thissize
= 0;
468 if (p
->type
== bfd_indirect_link_order
)
472 sec
= p
->u
.indirect
.section
;
474 if (info
->strip
== strip_none
475 || info
->strip
== strip_some
)
476 thislines
= sec
->lineno_count
;
478 if (info
->relocatable
)
479 thisrelocs
= sec
->reloc_count
;
481 thissize
= sec
->size
;
484 else if (info
->relocatable
485 && (p
->type
== bfd_section_reloc_link_order
486 || p
->type
== bfd_symbol_reloc_link_order
))
490 && (thisrelocs
+ relocs
>= config
.split_by_reloc
491 || thislines
+ lines
>= config
.split_by_reloc
492 || (thissize
+ sec_size
>= config
.split_by_file
))
493 && !unsplittable_name (cursor
->name
))
495 /* Create a new section and put this link order and the
496 following link orders into it. */
497 bfd_vma shift_offset
;
500 n
= clone_section (abfd
, cursor
, original_sec
->name
, &count
);
502 /* Attach the link orders to the new section and snip
503 them off from the old section. */
504 n
->map_head
.link_order
= p
;
505 n
->map_tail
.link_order
= cursor
->map_tail
.link_order
;
506 cursor
->map_tail
.link_order
= l
;
510 /* Change the size of the original section and
511 update the vma of the new one. */
513 dump ("before snip", cursor
, n
);
515 shift_offset
= p
->offset
;
516 n
->size
= cursor
->size
- shift_offset
;
517 cursor
->size
= shift_offset
;
520 n
->lma
= n
->vma
= vma
;
522 /* Run down the chain and change the output section to
523 the right one, update the offsets too. */
526 p
->offset
-= shift_offset
;
527 if (p
->type
== bfd_indirect_link_order
)
529 p
->u
.indirect
.section
->output_section
= n
;
530 p
->u
.indirect
.section
->output_offset
= p
->offset
;
536 dump ("after snip", cursor
, n
);
545 relocs
+= thisrelocs
;
547 sec_size
+= thissize
;
554 /* Call BFD to write out the linked file. */
559 /* Reset error indicator, which can typically something like invalid
560 format from opening up the .o files. */
561 bfd_set_error (bfd_error_no_error
);
562 lang_for_each_statement (build_link_order
);
564 if (config
.split_by_reloc
!= (unsigned) -1
565 || config
.split_by_file
!= (bfd_size_type
) -1)
566 split_sections (link_info
.output_bfd
, &link_info
);
567 if (!bfd_final_link (link_info
.output_bfd
, &link_info
))
569 /* If there was an error recorded, print it out. Otherwise assume
570 an appropriate error message like unknown symbol was printed
573 if (bfd_get_error () != bfd_error_no_error
)
574 einfo (_("%F%P: final link failed: %E\n"));