gas/
[binutils.git] / ld / ldwrite.c
blobb7a1469c06a3696fd2efeac437f58f18e2f09eeb
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, 2010
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain sac@cygnus.com
7 This file is part of the GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 #include "sysdep.h"
25 #include "bfd.h"
26 #include "bfdlink.h"
27 #include "libiberty.h"
28 #include "safe-ctype.h"
30 #include "ld.h"
31 #include "ldexp.h"
32 #include "ldlang.h"
33 #include "ldwrite.h"
34 #include "ldmisc.h"
35 #include <ldgram.h>
36 #include "ldmain.h"
38 /* Build link_order structures for the BFD linker. */
40 static void
41 build_link_order (lang_statement_union_type *statement)
43 switch (statement->header.type)
45 case lang_data_statement_enum:
47 asection *output_section;
48 struct bfd_link_order *link_order;
49 bfd_vma value;
50 bfd_boolean big_endian = FALSE;
52 output_section = statement->data_statement.output_section;
53 ASSERT (output_section->owner == link_info.output_bfd);
55 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
56 || ((output_section->flags & SEC_LOAD) != 0
57 && (output_section->flags & SEC_THREAD_LOCAL))))
58 break;
60 link_order = bfd_new_link_order (link_info.output_bfd, output_section);
61 if (link_order == NULL)
62 einfo (_("%P%F: bfd_new_link_order failed\n"));
64 link_order->type = bfd_data_link_order;
65 link_order->offset = statement->data_statement.output_offset;
66 link_order->u.data.contents = (bfd_byte *) xmalloc (QUAD_SIZE);
68 value = statement->data_statement.value;
70 /* If the endianness of the output BFD is not known, then we
71 base the endianness of the data on the first input file.
72 By convention, the bfd_put routines for an unknown
73 endianness are big endian, so we must swap here if the
74 input file is little endian. */
75 if (bfd_big_endian (link_info.output_bfd))
76 big_endian = TRUE;
77 else if (bfd_little_endian (link_info.output_bfd))
78 big_endian = FALSE;
79 else
81 bfd_boolean swap;
83 swap = FALSE;
84 if (command_line.endian == ENDIAN_BIG)
85 big_endian = TRUE;
86 else if (command_line.endian == ENDIAN_LITTLE)
88 big_endian = FALSE;
89 swap = TRUE;
91 else if (command_line.endian == ENDIAN_UNSET)
93 big_endian = TRUE;
95 LANG_FOR_EACH_INPUT_STATEMENT (s)
97 if (s->the_bfd != NULL)
99 if (bfd_little_endian (s->the_bfd))
101 big_endian = FALSE;
102 swap = TRUE;
104 break;
110 if (swap)
112 bfd_byte buffer[8];
114 switch (statement->data_statement.type)
116 case QUAD:
117 case SQUAD:
118 if (sizeof (bfd_vma) >= QUAD_SIZE)
120 bfd_putl64 (value, buffer);
121 value = bfd_getb64 (buffer);
122 break;
124 /* Fall through. */
125 case LONG:
126 bfd_putl32 (value, buffer);
127 value = bfd_getb32 (buffer);
128 break;
129 case SHORT:
130 bfd_putl16 (value, buffer);
131 value = bfd_getb16 (buffer);
132 break;
133 case BYTE:
134 break;
135 default:
136 abort ();
141 ASSERT (output_section->owner == link_info.output_bfd);
142 switch (statement->data_statement.type)
144 case QUAD:
145 case SQUAD:
146 if (sizeof (bfd_vma) >= QUAD_SIZE)
147 bfd_put_64 (link_info.output_bfd, value,
148 link_order->u.data.contents);
149 else
151 bfd_vma high;
153 if (statement->data_statement.type == QUAD)
154 high = 0;
155 else if ((value & 0x80000000) == 0)
156 high = 0;
157 else
158 high = (bfd_vma) -1;
159 bfd_put_32 (link_info.output_bfd, high,
160 (link_order->u.data.contents
161 + (big_endian ? 0 : 4)));
162 bfd_put_32 (link_info.output_bfd, value,
163 (link_order->u.data.contents
164 + (big_endian ? 4 : 0)));
166 link_order->size = QUAD_SIZE;
167 break;
168 case LONG:
169 bfd_put_32 (link_info.output_bfd, value,
170 link_order->u.data.contents);
171 link_order->size = LONG_SIZE;
172 break;
173 case SHORT:
174 bfd_put_16 (link_info.output_bfd, value,
175 link_order->u.data.contents);
176 link_order->size = SHORT_SIZE;
177 break;
178 case BYTE:
179 bfd_put_8 (link_info.output_bfd, value,
180 link_order->u.data.contents);
181 link_order->size = BYTE_SIZE;
182 break;
183 default:
184 abort ();
187 break;
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))))
203 break;
205 link_order = bfd_new_link_order (link_info.output_bfd, output_section);
206 if (link_order == NULL)
207 einfo (_("%P%F: 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;
223 else
225 link_order->u.reloc.p->u.section = rs->section->output_section;
226 link_order->u.reloc.p->addend += rs->section->output_offset;
229 else
231 link_order->type = bfd_symbol_reloc_link_order;
232 link_order->u.reloc.p->u.name = rs->name;
235 break;
237 case lang_input_section_enum:
239 /* Create a new link_order in the output section with this
240 attached */
241 asection *i = statement->input_section.section;
243 if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
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))))
254 break;
256 link_order = bfd_new_link_order (link_info.output_bfd,
257 output_section);
259 if ((i->flags & SEC_NEVER_LOAD) != 0
260 && (i->flags & SEC_DEBUGGING) == 0)
262 /* We've got a never load section inside one which is
263 going to be output, we'll change it into a fill. */
264 link_order->type = bfd_data_link_order;
265 link_order->u.data.contents = (unsigned char *) "";
266 link_order->u.data.size = 1;
268 else
270 link_order->type = bfd_indirect_link_order;
271 link_order->u.indirect.section = i;
272 ASSERT (i->output_section == output_section);
274 link_order->size = i->size;
275 link_order->offset = i->output_offset;
278 break;
280 case lang_padding_statement_enum:
281 /* Make a new link_order with the right filler */
283 asection *output_section;
284 struct bfd_link_order *link_order;
286 output_section = statement->padding_statement.output_section;
287 ASSERT (statement->padding_statement.output_section->owner
288 == link_info.output_bfd);
290 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
291 || ((output_section->flags & SEC_LOAD) != 0
292 && (output_section->flags & SEC_THREAD_LOCAL))))
293 break;
295 link_order = bfd_new_link_order (link_info.output_bfd,
296 output_section);
297 link_order->type = bfd_data_link_order;
298 link_order->size = statement->padding_statement.size;
299 link_order->offset = statement->padding_statement.output_offset;
300 link_order->u.data.contents = statement->padding_statement.fill->data;
301 link_order->u.data.size = statement->padding_statement.fill->size;
303 break;
305 default:
306 /* All the other ones fall through */
307 break;
311 /* Return true if NAME is the name of an unsplittable section. These
312 are the stabs strings, dwarf strings. */
314 static bfd_boolean
315 unsplittable_name (const char *name)
317 if (CONST_STRNEQ (name, ".stab"))
319 /* There are several stab like string sections. We pattern match on
320 ".stab...str" */
321 unsigned len = strlen (name);
322 if (strcmp (&name[len-3], "str") == 0)
323 return TRUE;
325 else if (strcmp (name, "$GDB_STRINGS$") == 0)
326 return TRUE;
327 return FALSE;
330 /* Wander around the input sections, make sure that
331 we'll never try and create an output section with more relocs
332 than will fit.. Do this by always assuming the worst case, and
333 creating new output sections with all the right bits. */
334 #define TESTIT 1
335 static asection *
336 clone_section (bfd *abfd, asection *s, const char *name, int *count)
338 char *tname;
339 char *sname;
340 unsigned int len;
341 asection *n;
342 struct bfd_link_hash_entry *h;
344 /* Invent a section name from the section name and a dotted numeric
345 suffix. */
346 len = strlen (name);
347 tname = (char *) xmalloc (len + 1);
348 memcpy (tname, name, len + 1);
349 /* Remove a dotted number suffix, from a previous split link. */
350 while (len && ISDIGIT (tname[len-1]))
351 len--;
352 if (len > 1 && tname[len-1] == '.')
353 /* It was a dotted number. */
354 tname[len-1] = 0;
356 /* We want to use the whole of the original section name for the
357 split name, but coff can be restricted to 8 character names. */
358 if (bfd_family_coff (abfd) && strlen (tname) > 5)
360 /* Some section names cannot be truncated, as the name is
361 used to locate some other section. */
362 if (CONST_STRNEQ (name, ".stab")
363 || strcmp (name, "$GDB_SYMBOLS$") == 0)
365 einfo (_ ("%F%P: cannot create split section name for %s\n"), name);
366 /* Silence gcc warnings. einfo exits, so we never reach here. */
367 return NULL;
369 tname[5] = 0;
372 if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL
373 || (n = bfd_make_section_anyway (abfd, sname)) == NULL
374 || (h = bfd_link_hash_lookup (link_info.hash,
375 sname, TRUE, TRUE, FALSE)) == NULL)
377 einfo (_("%F%P: clone section failed: %E\n"));
378 /* Silence gcc warnings. einfo exits, so we never reach here. */
379 return NULL;
381 free (tname);
383 /* Set up section symbol. */
384 h->type = bfd_link_hash_defined;
385 h->u.def.value = 0;
386 h->u.def.section = n;
388 n->flags = s->flags;
389 n->vma = s->vma;
390 n->user_set_vma = s->user_set_vma;
391 n->lma = s->lma;
392 n->size = 0;
393 n->output_offset = s->output_offset;
394 n->output_section = n;
395 n->orelocation = 0;
396 n->reloc_count = 0;
397 n->alignment_power = s->alignment_power;
399 bfd_copy_private_section_data (abfd, s, abfd, n);
401 return n;
404 #if TESTING
405 static void
406 ds (asection *s)
408 struct bfd_link_order *l = s->map_head.link_order;
409 printf ("vma %x size %x\n", s->vma, s->size);
410 while (l)
412 if (l->type == bfd_indirect_link_order)
414 printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
416 else
418 printf (_("%8x something else\n"), l->offset);
420 l = l->next;
422 printf ("\n");
425 dump (char *s, asection *a1, asection *a2)
427 printf ("%s\n", s);
428 ds (a1);
429 ds (a2);
432 static void
433 sanity_check (bfd *abfd)
435 asection *s;
436 for (s = abfd->sections; s; s = s->next)
438 struct bfd_link_order *p;
439 bfd_vma prev = 0;
440 for (p = s->map_head.link_order; p; p = p->next)
442 if (p->offset > 100000)
443 abort ();
444 if (p->offset < prev)
445 abort ();
446 prev = p->offset;
450 #else
451 #define sanity_check(a)
452 #define dump(a, b, c)
453 #endif
455 static void
456 split_sections (bfd *abfd, struct bfd_link_info *info)
458 asection *original_sec;
459 int nsecs = abfd->section_count;
460 sanity_check (abfd);
461 /* Look through all the original sections. */
462 for (original_sec = abfd->sections;
463 original_sec && nsecs;
464 original_sec = original_sec->next, nsecs--)
466 int count = 0;
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)
484 asection *sec;
486 sec = p->u.indirect.section;
488 if (info->strip == strip_none
489 || info->strip == strip_some)
490 thislines = sec->lineno_count;
492 if (info->relocatable)
493 thisrelocs = sec->reloc_count;
495 thissize = sec->size;
498 else if (info->relocatable
499 && (p->type == bfd_section_reloc_link_order
500 || p->type == bfd_symbol_reloc_link_order))
501 thisrelocs++;
503 if (l != NULL
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;
512 asection *n;
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;
521 l->next = NULL;
522 l = p;
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;
533 vma += 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;
546 p = p->next;
548 while (p);
550 dump ("after snip", cursor, n);
551 cursor = n;
552 relocs = thisrelocs;
553 lines = thislines;
554 sec_size = thissize;
556 else
558 l = p;
559 relocs += thisrelocs;
560 lines += thislines;
561 sec_size += thissize;
565 sanity_check (abfd);
568 /* Call BFD to write out the linked file. */
570 void
571 ldwrite (void)
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_for_each_statement (build_link_order);
578 if (config.split_by_reloc != (unsigned) -1
579 || config.split_by_file != (bfd_size_type) -1)
580 split_sections (link_info.output_bfd, &link_info);
581 if (!bfd_final_link (link_info.output_bfd, &link_info))
583 /* If there was an error recorded, print it out. Otherwise assume
584 an appropriate error message like unknown symbol was printed
585 out. */
587 if (bfd_get_error () != bfd_error_no_error)
588 einfo (_("%F%P: final link failed: %E\n"));
589 else
590 xexit (1);