1 /* ldwrite.c -- write out the linked file
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 2000
3 Free Software Foundation, Inc.
4 Written by Steve Chamberlain sac@cygnus.com
6 This file is part of GLD, the Gnu Linker.
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "libiberty.h"
35 static void build_link_order PARAMS ((lang_statement_union_type *));
36 static asection *clone_section PARAMS ((bfd *, asection *, const char *, int *));
37 static void split_sections PARAMS ((bfd *, struct bfd_link_info *));
39 /* Build link_order structures for the BFD linker. */
42 build_link_order (statement)
43 lang_statement_union_type *statement;
45 switch (statement->header.type)
47 case lang_data_statement_enum:
49 asection *output_section;
50 struct bfd_link_order *link_order;
52 boolean big_endian = false;
54 output_section = statement->data_statement.output_section;
55 ASSERT (output_section->owner == output_bfd);
57 link_order = bfd_new_link_order (output_bfd, output_section);
58 if (link_order == NULL)
59 einfo (_("%P%F: bfd_new_link_order failed\n"));
61 link_order->type = bfd_data_link_order;
62 link_order->offset = statement->data_statement.output_vma;
63 link_order->u.data.contents = (bfd_byte *) xmalloc (QUAD_SIZE);
65 value = statement->data_statement.value;
67 /* If the endianness of the output BFD is not known, then we
68 base the endianness of the data on the first input file.
69 By convention, the bfd_put routines for an unknown
70 endianness are big endian, so we must swap here if the
71 input file is little endian. */
72 if (bfd_big_endian (output_bfd))
74 else if (bfd_little_endian (output_bfd))
81 if (command_line.endian == ENDIAN_BIG)
83 else if (command_line.endian == ENDIAN_LITTLE)
88 else if (command_line.endian == ENDIAN_UNSET)
92 LANG_FOR_EACH_INPUT_STATEMENT (s)
94 if (s->the_bfd != NULL)
96 if (bfd_little_endian (s->the_bfd))
111 switch (statement->data_statement.type)
115 if (sizeof (bfd_vma) >= QUAD_SIZE)
117 bfd_putl64 (value, buffer);
118 value = bfd_getb64 (buffer);
123 bfd_putl32 (value, buffer);
124 value = bfd_getb32 (buffer);
127 bfd_putl16 (value, buffer);
128 value = bfd_getb16 (buffer);
138 ASSERT (output_section->owner == output_bfd);
139 switch (statement->data_statement.type)
143 if (sizeof (bfd_vma) >= QUAD_SIZE)
144 bfd_put_64 (output_bfd, value, link_order->u.data.contents);
149 if (statement->data_statement.type == QUAD)
151 else if ((value & 0x80000000) == 0)
155 bfd_put_32 (output_bfd, high,
156 (link_order->u.data.contents
157 + (big_endian ? 0 : 4)));
158 bfd_put_32 (output_bfd, value,
159 (link_order->u.data.contents
160 + (big_endian ? 4 : 0)));
162 link_order->size = QUAD_SIZE;
165 bfd_put_32 (output_bfd, value, link_order->u.data.contents);
166 link_order->size = LONG_SIZE;
169 bfd_put_16 (output_bfd, value, link_order->u.data.contents);
170 link_order->size = SHORT_SIZE;
173 bfd_put_8 (output_bfd, value, link_order->u.data.contents);
174 link_order->size = BYTE_SIZE;
182 case lang_reloc_statement_enum:
184 lang_reloc_statement_type *rs;
185 asection *output_section;
186 struct bfd_link_order *link_order;
188 rs = &statement->reloc_statement;
190 output_section = rs->output_section;
191 ASSERT (output_section->owner == output_bfd);
193 link_order = bfd_new_link_order (output_bfd, output_section);
194 if (link_order == NULL)
195 einfo (_("%P%F: bfd_new_link_order failed\n"));
197 link_order->offset = rs->output_vma;
198 link_order->size = bfd_get_reloc_size (rs->howto);
200 link_order->u.reloc.p =
201 ((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 == 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:
227 /* Create a new link_order in the output section with this
229 if (statement->input_section.ifile->just_syms_flag == false)
231 asection *i = statement->input_section.section;
232 asection *output_section = i->output_section;
234 ASSERT (output_section->owner == output_bfd);
236 if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
238 struct bfd_link_order *link_order;
240 link_order = bfd_new_link_order (output_bfd, output_section);
242 if (i->flags & SEC_NEVER_LOAD)
244 /* We've got a never load section inside one which
245 is going to be output, we'll change it into a
247 link_order->type = bfd_fill_link_order;
248 link_order->u.fill.value = 0;
252 link_order->type = bfd_indirect_link_order;
253 link_order->u.indirect.section = i;
254 ASSERT (i->output_section == output_section);
257 link_order->size = i->_cooked_size;
259 link_order->size = bfd_get_section_size_before_reloc (i);
260 link_order->offset = i->output_offset;
265 case lang_padding_statement_enum:
266 /* Make a new link_order with the right filler */
268 asection *output_section;
269 struct bfd_link_order *link_order;
271 output_section = statement->padding_statement.output_section;
272 ASSERT (statement->padding_statement.output_section->owner
274 if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
276 link_order = bfd_new_link_order (output_bfd, output_section);
277 link_order->type = bfd_fill_link_order;
278 link_order->size = statement->padding_statement.size;
279 link_order->offset = statement->padding_statement.output_offset;
280 link_order->u.fill.value = statement->padding_statement.fill;
286 /* All the other ones fall through */
291 /* Call BFD to write out the linked file. */
294 /**********************************************************************/
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. */
303 clone_section (abfd, s, name, count)
312 struct bfd_link_hash_entry *h;
314 /* Invent a section name from the first five chars of the base
315 section name and a digit suffix. */
316 strncpy (templ, name, sizeof (templ) - 1);
317 templ[sizeof (templ) - 1] = '\0';
318 if ((sname = bfd_get_unique_section_name (abfd, templ, count)) == NULL
319 || (n = bfd_make_section_anyway (abfd, sname)) == NULL
320 || (h = bfd_link_hash_lookup (link_info.hash,
321 sname, true, true, false)) == NULL)
322 einfo (_("%F%P: clone section failed: %E\n"));
324 /* Set up section symbol. */
325 h->type = bfd_link_hash_defined;
327 h->u.def.section = n;
331 n->user_set_vma = s->user_set_vma;
335 n->output_offset = s->output_offset;
336 n->output_section = n;
339 n->alignment_power = s->alignment_power;
348 struct bfd_link_order *l = s->link_order_head;
349 printf ("vma %x size %x\n", s->vma, s->_raw_size);
352 if (l->type == bfd_indirect_link_order)
354 printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
358 printf (_("%8x something else\n"), l->offset);
379 for (s = abfd->sections; s; s = s->next)
381 struct bfd_link_order *p;
383 for (p = s->link_order_head; p; p = p->next)
385 if (p->offset > 100000)
387 if (p->offset < prev)
394 #define sanity_check(a)
395 #define dump(a, b, c)
399 split_sections (abfd, info)
401 struct bfd_link_info *info;
403 asection *original_sec;
404 int nsecs = abfd->section_count;
406 /* Look through all the original sections. */
407 for (original_sec = abfd->sections;
408 original_sec && nsecs;
409 original_sec = original_sec->next, nsecs--)
412 unsigned int lines = 0;
413 unsigned int relocs = 0;
414 bfd_size_type sec_size = 0;
415 struct bfd_link_order *l;
416 struct bfd_link_order *p;
417 bfd_vma vma = original_sec->vma;
418 asection *cursor = original_sec;
420 /* Count up the relocations and line entries to see if anything
421 would be too big to fit. Accumulate section size too. */
422 for (l = NULL, p = cursor->link_order_head; p != NULL; p = l->next)
424 unsigned int thislines = 0;
425 unsigned int thisrelocs = 0;
426 bfd_size_type thissize = 0;
427 if (p->type == bfd_indirect_link_order)
431 sec = p->u.indirect.section;
433 if (info->strip == strip_none
434 || info->strip == strip_some)
435 thislines = sec->lineno_count;
437 if (info->relocateable)
438 thisrelocs = sec->reloc_count;
440 if (sec->_cooked_size != 0)
441 thissize = sec->_cooked_size;
443 thissize = sec->_raw_size;
446 else if (info->relocateable
447 && (p->type == bfd_section_reloc_link_order
448 || p->type == bfd_symbol_reloc_link_order))
452 && (thisrelocs + relocs >= config.split_by_reloc
453 || thislines + lines >= config.split_by_reloc
454 || thissize + sec_size >= config.split_by_file))
456 /* Create a new section and put this link order and the
457 following link orders into it. */
458 bfd_vma shift_offset;
461 n = clone_section (abfd, cursor, original_sec->name, &count);
463 /* Attach the link orders to the new section and snip
464 them off from the old section. */
465 n->link_order_head = p;
466 n->link_order_tail = cursor->link_order_tail;
467 cursor->link_order_tail = l;
471 /* Change the size of the original section and
472 update the vma of the new one. */
474 dump ("before snip", cursor, n);
476 shift_offset = p->offset;
477 if (cursor->_cooked_size != 0)
479 n->_cooked_size = cursor->_cooked_size - shift_offset;
480 cursor->_cooked_size = shift_offset;
482 n->_raw_size = cursor->_raw_size - shift_offset;
483 cursor->_raw_size = shift_offset;
486 n->lma = n->vma = vma;
488 /* Run down the chain and change the output section to
489 the right one, update the offsets too. */
492 p->offset -= shift_offset;
493 if (p->type == bfd_indirect_link_order)
495 p->u.indirect.section->output_section = n;
496 p->u.indirect.section->output_offset = p->offset;
502 dump ("after snip", cursor, n);
511 relocs += thisrelocs;
513 sec_size += thissize;
519 /**********************************************************************/
523 /* Reset error indicator, which can typically something like invalid
524 format from opening up the .o files. */
525 bfd_set_error (bfd_error_no_error);
526 lang_for_each_statement (build_link_order);
528 if (config.split_by_reloc != (unsigned) -1
529 || config.split_by_file != (bfd_size_type) -1)
530 split_sections (output_bfd, &link_info);
531 if (!bfd_final_link (output_bfd, &link_info))
533 /* If there was an error recorded, print it out. Otherwise assume
534 an appropriate error message like unknown symbol was printed
537 if (bfd_get_error () != bfd_error_no_error)
538 einfo (_("%F%P: final link failed: %E\n"));