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 = (bfd_byte *) 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 = (struct bfd_link_order_reloc *)
202 xmalloc (sizeof (struct bfd_link_order_reloc));
204 link_order->u.reloc.p->reloc = rs->reloc;
205 link_order->u.reloc.p->addend = rs->addend_value;
207 if (rs->name == NULL)
209 link_order->type = bfd_section_reloc_link_order;
210 if (rs->section->owner == link_info.output_bfd)
211 link_order->u.reloc.p->u.section = rs->section;
214 link_order->u.reloc.p->u.section = rs->section->output_section;
215 link_order->u.reloc.p->addend += rs->section->output_offset;
220 link_order->type = bfd_symbol_reloc_link_order;
221 link_order->u.reloc.p->u.name = rs->name;
226 case lang_input_section_enum:
228 /* Create a new link_order in the output section with this
230 asection *i = statement->input_section.section;
232 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
233 && (i->flags & SEC_EXCLUDE) == 0)
235 asection *output_section = i->output_section;
237 ASSERT (output_section->owner == link_info.output_bfd);
239 if ((output_section->flags & SEC_HAS_CONTENTS) != 0
240 || ((output_section->flags & SEC_LOAD) != 0
241 && (output_section->flags & SEC_THREAD_LOCAL)))
243 struct bfd_link_order *link_order;
245 link_order = bfd_new_link_order (link_info.output_bfd,
248 if (i->flags & SEC_NEVER_LOAD)
250 /* We've got a never load section inside one which
251 is going to be output, we'll change it into a
253 link_order->type = bfd_data_link_order;
254 link_order->u.data.contents = (unsigned char *) "";
255 link_order->u.data.size = 1;
259 link_order->type = bfd_indirect_link_order;
260 link_order->u.indirect.section = i;
261 ASSERT (i->output_section == output_section);
263 link_order->size = i->size;
264 link_order->offset = i->output_offset;
270 case lang_padding_statement_enum:
271 /* Make a new link_order with the right filler */
273 asection *output_section;
274 struct bfd_link_order *link_order;
276 output_section = statement->padding_statement.output_section;
277 ASSERT (statement->padding_statement.output_section->owner
278 == link_info.output_bfd);
279 if ((output_section->flags & SEC_HAS_CONTENTS) != 0
280 || ((output_section->flags & SEC_LOAD) != 0
281 && (output_section->flags & SEC_THREAD_LOCAL)))
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 = (char *) 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;
388 bfd_copy_private_section_data (abfd, s, abfd, n);
397 struct bfd_link_order *l = s->map_head.link_order;
398 printf ("vma %x size %x\n", s->vma, s->size);
401 if (l->type == bfd_indirect_link_order)
403 printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
407 printf (_("%8x something else\n"), l->offset);
414 dump (char *s, asection *a1, asection *a2)
422 sanity_check (bfd *abfd)
425 for (s = abfd->sections; s; s = s->next)
427 struct bfd_link_order *p;
429 for (p = s->map_head.link_order; p; p = p->next)
431 if (p->offset > 100000)
433 if (p->offset < prev)
440 #define sanity_check(a)
441 #define dump(a, b, c)
445 split_sections (bfd *abfd, struct bfd_link_info *info)
447 asection *original_sec;
448 int nsecs = abfd->section_count;
450 /* Look through all the original sections. */
451 for (original_sec = abfd->sections;
452 original_sec && nsecs;
453 original_sec = original_sec->next, nsecs--)
456 unsigned int lines = 0;
457 unsigned int relocs = 0;
458 bfd_size_type sec_size = 0;
459 struct bfd_link_order *l;
460 struct bfd_link_order *p;
461 bfd_vma vma = original_sec->vma;
462 asection *cursor = original_sec;
464 /* Count up the relocations and line entries to see if anything
465 would be too big to fit. Accumulate section size too. */
466 for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next)
468 unsigned int thislines = 0;
469 unsigned int thisrelocs = 0;
470 bfd_size_type thissize = 0;
471 if (p->type == bfd_indirect_link_order)
475 sec = p->u.indirect.section;
477 if (info->strip == strip_none
478 || info->strip == strip_some)
479 thislines = sec->lineno_count;
481 if (info->relocatable)
482 thisrelocs = sec->reloc_count;
484 thissize = sec->size;
487 else if (info->relocatable
488 && (p->type == bfd_section_reloc_link_order
489 || p->type == bfd_symbol_reloc_link_order))
493 && (thisrelocs + relocs >= config.split_by_reloc
494 || thislines + lines >= config.split_by_reloc
495 || (thissize + sec_size >= config.split_by_file))
496 && !unsplittable_name (cursor->name))
498 /* Create a new section and put this link order and the
499 following link orders into it. */
500 bfd_vma shift_offset;
503 n = clone_section (abfd, cursor, original_sec->name, &count);
505 /* Attach the link orders to the new section and snip
506 them off from the old section. */
507 n->map_head.link_order = p;
508 n->map_tail.link_order = cursor->map_tail.link_order;
509 cursor->map_tail.link_order = l;
513 /* Change the size of the original section and
514 update the vma of the new one. */
516 dump ("before snip", cursor, n);
518 shift_offset = p->offset;
519 n->size = cursor->size - shift_offset;
520 cursor->size = shift_offset;
523 n->lma = n->vma = vma;
525 /* Run down the chain and change the output section to
526 the right one, update the offsets too. */
529 p->offset -= shift_offset;
530 if (p->type == bfd_indirect_link_order)
532 p->u.indirect.section->output_section = n;
533 p->u.indirect.section->output_offset = p->offset;
539 dump ("after snip", cursor, n);
548 relocs += thisrelocs;
550 sec_size += thissize;
557 /* Call BFD to write out the linked file. */
562 /* Reset error indicator, which can typically something like invalid
563 format from opening up the .o files. */
564 bfd_set_error (bfd_error_no_error);
565 lang_for_each_statement (build_link_order);
567 if (config.split_by_reloc != (unsigned) -1
568 || config.split_by_file != (bfd_size_type) -1)
569 split_sections (link_info.output_bfd, &link_info);
570 if (!bfd_final_link (link_info.output_bfd, &link_info))
572 /* If there was an error recorded, print it out. Otherwise assume
573 an appropriate error message like unknown symbol was printed
576 if (bfd_get_error () != bfd_error_no_error)
577 einfo (_("%F%P: final link failed: %E\n"));