1 /* ldwrite.c -- write out the linked file
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
3 Written by Steve Chamberlain sac@cygnus.com
4
5 This file is part of the GNU Binutils.
6
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.
11
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.
16
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. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libiberty.h"
26 #include "safe-ctype.h"
27
28 #include "ld.h"
29 #include "ldexp.h"
30 #include "ldlang.h"
31 #include "ldwrite.h"
32 #include "ldmisc.h"
33 #include <ldgram.h>
34 #include "ldmain.h"
35
36 /* Build link_order structures for the BFD linker. */
37
38 static void
build_link_order(lang_statement_union_type * statement)39 build_link_order (lang_statement_union_type *statement)
40 {
41 switch (statement->header.type)
42 {
43 case lang_data_statement_enum:
44 {
45 asection *output_section;
46 struct bfd_link_order *link_order;
47 bfd_vma value;
48 bfd_boolean big_endian = FALSE;
49
50 output_section = statement->data_statement.output_section;
51 ASSERT (output_section->owner == link_info.output_bfd);
52
53 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
54 || ((output_section->flags & SEC_LOAD) != 0
55 && (output_section->flags & SEC_THREAD_LOCAL))))
56 break;
57
58 link_order = bfd_new_link_order (link_info.output_bfd, output_section);
59 if (link_order == NULL)
60 einfo (_("%P%F: bfd_new_link_order failed\n"));
61
62 link_order->type = bfd_data_link_order;
63 link_order->offset = statement->data_statement.output_offset;
64 link_order->u.data.contents = (bfd_byte *) xmalloc (QUAD_SIZE);
65
66 value = statement->data_statement.value;
67
68 /* If the endianness of the output BFD is not known, then we
69 base the endianness of the data on the first input file.
70 By convention, the bfd_put routines for an unknown
71 endianness are big endian, so we must swap here if the
72 input file is little endian. */
73 if (bfd_big_endian (link_info.output_bfd))
74 big_endian = TRUE;
75 else if (bfd_little_endian (link_info.output_bfd))
76 big_endian = FALSE;
77 else
78 {
79 bfd_boolean swap;
80
81 swap = FALSE;
82 if (command_line.endian == ENDIAN_BIG)
83 big_endian = TRUE;
84 else if (command_line.endian == ENDIAN_LITTLE)
85 {
86 big_endian = FALSE;
87 swap = TRUE;
88 }
89 else if (command_line.endian == ENDIAN_UNSET)
90 {
91 big_endian = TRUE;
92 {
93 LANG_FOR_EACH_INPUT_STATEMENT (s)
94 {
95 if (s->the_bfd != NULL)
96 {
97 if (bfd_little_endian (s->the_bfd))
98 {
99 big_endian = FALSE;
100 swap = TRUE;
101 }
102 break;
103 }
104 }
105 }
106 }
107
108 if (swap)
109 {
110 bfd_byte buffer[8];
111
112 switch (statement->data_statement.type)
113 {
114 case QUAD:
115 case SQUAD:
116 if (sizeof (bfd_vma) >= QUAD_SIZE)
117 {
118 bfd_putl64 (value, buffer);
119 value = bfd_getb64 (buffer);
120 break;
121 }
122 /* Fall through. */
123 case LONG:
124 bfd_putl32 (value, buffer);
125 value = bfd_getb32 (buffer);
126 break;
127 case SHORT:
128 bfd_putl16 (value, buffer);
129 value = bfd_getb16 (buffer);
130 break;
131 case BYTE:
132 break;
133 default:
134 abort ();
135 }
136 }
137 }
138
139 ASSERT (output_section->owner == link_info.output_bfd);
140 switch (statement->data_statement.type)
141 {
142 case QUAD:
143 case SQUAD:
144 if (sizeof (bfd_vma) >= QUAD_SIZE)
145 bfd_put_64 (link_info.output_bfd, value,
146 link_order->u.data.contents);
147 else
148 {
149 bfd_vma high;
150
151 if (statement->data_statement.type == QUAD)
152 high = 0;
153 else if ((value & 0x80000000) == 0)
154 high = 0;
155 else
156 high = (bfd_vma) -1;
157 bfd_put_32 (link_info.output_bfd, high,
158 (link_order->u.data.contents
159 + (big_endian ? 0 : 4)));
160 bfd_put_32 (link_info.output_bfd, value,
161 (link_order->u.data.contents
162 + (big_endian ? 4 : 0)));
163 }
164 link_order->size = QUAD_SIZE;
165 break;
166 case LONG:
167 bfd_put_32 (link_info.output_bfd, value,
168 link_order->u.data.contents);
169 link_order->size = LONG_SIZE;
170 break;
171 case SHORT:
172 bfd_put_16 (link_info.output_bfd, value,
173 link_order->u.data.contents);
174 link_order->size = SHORT_SIZE;
175 break;
176 case BYTE:
177 bfd_put_8 (link_info.output_bfd, value,
178 link_order->u.data.contents);
179 link_order->size = BYTE_SIZE;
180 break;
181 default:
182 abort ();
183 }
184 link_order->u.data.size = link_order->size;
185 }
186 break;
187
188 case lang_reloc_statement_enum:
189 {
190 lang_reloc_statement_type *rs;
191 asection *output_section;
192 struct bfd_link_order *link_order;
193
194 rs = &statement->reloc_statement;
195
196 output_section = rs->output_section;
197 ASSERT (output_section->owner == link_info.output_bfd);
198
199 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
200 || ((output_section->flags & SEC_LOAD) != 0
201 && (output_section->flags & SEC_THREAD_LOCAL))))
202 break;
203
204 link_order = bfd_new_link_order (link_info.output_bfd, output_section);
205 if (link_order == NULL)
206 einfo (_("%P%F: bfd_new_link_order failed\n"));
207
208 link_order->offset = rs->output_offset;
209 link_order->size = bfd_get_reloc_size (rs->howto);
210
211 link_order->u.reloc.p = (struct bfd_link_order_reloc *)
212 xmalloc (sizeof (struct bfd_link_order_reloc));
213
214 link_order->u.reloc.p->reloc = rs->reloc;
215 link_order->u.reloc.p->addend = rs->addend_value;
216
217 if (rs->name == NULL)
218 {
219 link_order->type = bfd_section_reloc_link_order;
220 if (rs->section->owner == link_info.output_bfd)
221 link_order->u.reloc.p->u.section = rs->section;
222 else
223 {
224 link_order->u.reloc.p->u.section = rs->section->output_section;
225 link_order->u.reloc.p->addend += rs->section->output_offset;
226 }
227 }
228 else
229 {
230 link_order->type = bfd_symbol_reloc_link_order;
231 link_order->u.reloc.p->u.name = rs->name;
232 }
233 }
234 break;
235
236 case lang_input_section_enum:
237 {
238 /* Create a new link_order in the output section with this
239 attached */
240 asection *i = statement->input_section.section;
241
242 if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
243 && (i->flags & SEC_EXCLUDE) == 0)
244 {
245 asection *output_section = i->output_section;
246 struct bfd_link_order *link_order;
247
248 ASSERT (output_section->owner == link_info.output_bfd);
249
250 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
251 || ((output_section->flags & SEC_LOAD) != 0
252 && (output_section->flags & SEC_THREAD_LOCAL))))
253 break;
254
255 link_order = bfd_new_link_order (link_info.output_bfd,
256 output_section);
257
258 if ((i->flags & SEC_NEVER_LOAD) != 0
259 && (i->flags & SEC_DEBUGGING) == 0)
260 {
261 /* We've got a never load section inside one which is
262 going to be output, we'll change it into a fill. */
263 link_order->type = bfd_data_link_order;
264 link_order->u.data.contents = (unsigned char *) "";
265 link_order->u.data.size = 1;
266 }
267 else
268 {
269 link_order->type = bfd_indirect_link_order;
270 link_order->u.indirect.section = i;
271 ASSERT (i->output_section == output_section);
272 }
273 link_order->size = i->size;
274 link_order->offset = i->output_offset;
275 }
276 }
277 break;
278
279 case lang_padding_statement_enum:
280 /* Make a new link_order with the right filler */
281 {
282 asection *output_section;
283 struct bfd_link_order *link_order;
284
285 output_section = statement->padding_statement.output_section;
286 ASSERT (statement->padding_statement.output_section->owner
287 == link_info.output_bfd);
288
289 if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
290 || ((output_section->flags & SEC_LOAD) != 0
291 && (output_section->flags & SEC_THREAD_LOCAL))))
292 break;
293
294 link_order = bfd_new_link_order (link_info.output_bfd,
295 output_section);
296 link_order->type = bfd_data_link_order;
297 link_order->size = statement->padding_statement.size;
298 link_order->offset = statement->padding_statement.output_offset;
299 link_order->u.data.contents = statement->padding_statement.fill->data;
300 link_order->u.data.size = statement->padding_statement.fill->size;
301 }
302 break;
303
304 default:
305 /* All the other ones fall through */
306 break;
307 }
308 }
309
310 /* Return true if NAME is the name of an unsplittable section. These
311 are the stabs strings, dwarf strings. */
312
313 static bfd_boolean
unsplittable_name(const char * name)314 unsplittable_name (const char *name)
315 {
316 if (CONST_STRNEQ (name, ".stab"))
317 {
318 /* There are several stab like string sections. We pattern match on
319 ".stab...str" */
320 unsigned len = strlen (name);
321 if (strcmp (&name[len-3], "str") == 0)
322 return TRUE;
323 }
324 else if (strcmp (name, "$GDB_STRINGS$") == 0)
325 return TRUE;
326 return FALSE;
327 }
328
329 /* Wander around the input sections, make sure that
330 we'll never try and create an output section with more relocs
331 than will fit.. Do this by always assuming the worst case, and
332 creating new output sections with all the right bits. */
333 #define TESTIT 1
334 static asection *
clone_section(bfd * abfd,asection * s,const char * name,int * count)335 clone_section (bfd *abfd, asection *s, const char *name, int *count)
336 {
337 char *tname;
338 char *sname;
339 unsigned int len;
340 asection *n;
341 struct bfd_link_hash_entry *h;
342
343 /* Invent a section name from the section name and a dotted numeric
344 suffix. */
345 len = strlen (name);
346 tname = (char *) xmalloc (len + 1);
347 memcpy (tname, name, len + 1);
348 /* Remove a dotted number suffix, from a previous split link. */
349 while (len && ISDIGIT (tname[len-1]))
350 len--;
351 if (len > 1 && tname[len-1] == '.')
352 /* It was a dotted number. */
353 tname[len-1] = 0;
354
355 /* We want to use the whole of the original section name for the
356 split name, but coff can be restricted to 8 character names. */
357 if (bfd_family_coff (abfd) && strlen (tname) > 5)
358 {
359 /* Some section names cannot be truncated, as the name is
360 used to locate some other section. */
361 if (CONST_STRNEQ (name, ".stab")
362 || strcmp (name, "$GDB_SYMBOLS$") == 0)
363 {
364 einfo (_ ("%F%P: cannot create split section name for %s\n"), name);
365 /* Silence gcc warnings. einfo exits, so we never reach here. */
366 return NULL;
367 }
368 tname[5] = 0;
369 }
370
371 if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL
372 || (n = bfd_make_section_anyway (abfd, sname)) == NULL
373 || (h = bfd_link_hash_lookup (link_info.hash,
374 sname, TRUE, TRUE, FALSE)) == NULL)
375 {
376 einfo (_("%F%P: clone section failed: %E\n"));
377 /* Silence gcc warnings. einfo exits, so we never reach here. */
378 return NULL;
379 }
380 free (tname);
381
382 /* Set up section symbol. */
383 h->type = bfd_link_hash_defined;
384 h->u.def.value = 0;
385 h->u.def.section = n;
386
387 n->flags = s->flags;
388 n->vma = s->vma;
389 n->user_set_vma = s->user_set_vma;
390 n->lma = s->lma;
391 n->size = 0;
392 n->output_offset = s->output_offset;
393 n->output_section = n;
394 n->orelocation = 0;
395 n->reloc_count = 0;
396 n->alignment_power = s->alignment_power;
397
398 bfd_copy_private_section_data (abfd, s, abfd, n);
399
400 return n;
401 }
402
403 #if TESTING
404 static void
ds(asection * s)405 ds (asection *s)
406 {
407 struct bfd_link_order *l = s->map_head.link_order;
408 printf ("vma %x size %x\n", s->vma, s->size);
409 while (l)
410 {
411 if (l->type == bfd_indirect_link_order)
412 {
413 printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
414 }
415 else
416 {
417 printf (_("%8x something else\n"), l->offset);
418 }
419 l = l->next;
420 }
421 printf ("\n");
422 }
423
dump(char * s,asection * a1,asection * a2)424 dump (char *s, asection *a1, asection *a2)
425 {
426 printf ("%s\n", s);
427 ds (a1);
428 ds (a2);
429 }
430
431 static void
sanity_check(bfd * abfd)432 sanity_check (bfd *abfd)
433 {
434 asection *s;
435 for (s = abfd->sections; s; s = s->next)
436 {
437 struct bfd_link_order *p;
438 bfd_vma prev = 0;
439 for (p = s->map_head.link_order; p; p = p->next)
440 {
441 if (p->offset > 100000)
442 abort ();
443 if (p->offset < prev)
444 abort ();
445 prev = p->offset;
446 }
447 }
448 }
449 #else
450 #define sanity_check(a)
451 #define dump(a, b, c)
452 #endif
453
454 static void
split_sections(bfd * abfd,struct bfd_link_info * info)455 split_sections (bfd *abfd, struct bfd_link_info *info)
456 {
457 asection *original_sec;
458 int nsecs = abfd->section_count;
459 sanity_check (abfd);
460 /* Look through all the original sections. */
461 for (original_sec = abfd->sections;
462 original_sec && nsecs;
463 original_sec = original_sec->next, nsecs--)
464 {
465 int count = 0;
466 unsigned int lines = 0;
467 unsigned int relocs = 0;
468 bfd_size_type sec_size = 0;
469 struct bfd_link_order *l;
470 struct bfd_link_order *p;
471 bfd_vma vma = original_sec->vma;
472 asection *cursor = original_sec;
473
474 /* Count up the relocations and line entries to see if anything
475 would be too big to fit. Accumulate section size too. */
476 for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next)
477 {
478 unsigned int thislines = 0;
479 unsigned int thisrelocs = 0;
480 bfd_size_type thissize = 0;
481 if (p->type == bfd_indirect_link_order)
482 {
483 asection *sec;
484
485 sec = p->u.indirect.section;
486
487 if (info->strip == strip_none
488 || info->strip == strip_some)
489 thislines = sec->lineno_count;
490
491 if (info->relocatable)
492 thisrelocs = sec->reloc_count;
493
494 thissize = sec->size;
495
496 }
497 else if (info->relocatable
498 && (p->type == bfd_section_reloc_link_order
499 || p->type == bfd_symbol_reloc_link_order))
500 thisrelocs++;
501
502 if (l != NULL
503 && (thisrelocs + relocs >= config.split_by_reloc
504 || thislines + lines >= config.split_by_reloc
505 || (thissize + sec_size >= config.split_by_file))
506 && !unsplittable_name (cursor->name))
507 {
508 /* Create a new section and put this link order and the
509 following link orders into it. */
510 bfd_vma shift_offset;
511 asection *n;
512
513 n = clone_section (abfd, cursor, original_sec->name, &count);
514
515 /* Attach the link orders to the new section and snip
516 them off from the old section. */
517 n->map_head.link_order = p;
518 n->map_tail.link_order = cursor->map_tail.link_order;
519 cursor->map_tail.link_order = l;
520 l->next = NULL;
521 l = p;
522
523 /* Change the size of the original section and
524 update the vma of the new one. */
525
526 dump ("before snip", cursor, n);
527
528 shift_offset = p->offset;
529 n->size = cursor->size - shift_offset;
530 cursor->size = shift_offset;
531
532 vma += shift_offset;
533 n->lma = n->vma = vma;
534
535 /* Run down the chain and change the output section to
536 the right one, update the offsets too. */
537 do
538 {
539 p->offset -= shift_offset;
540 if (p->type == bfd_indirect_link_order)
541 {
542 p->u.indirect.section->output_section = n;
543 p->u.indirect.section->output_offset = p->offset;
544 }
545 p = p->next;
546 }
547 while (p);
548
549 dump ("after snip", cursor, n);
550 cursor = n;
551 relocs = thisrelocs;
552 lines = thislines;
553 sec_size = thissize;
554 }
555 else
556 {
557 l = p;
558 relocs += thisrelocs;
559 lines += thislines;
560 sec_size += thissize;
561 }
562 }
563 }
564 sanity_check (abfd);
565 }
566
567 /* Call BFD to write out the linked file. */
568
569 void
ldwrite(void)570 ldwrite (void)
571 {
572 /* Reset error indicator, which can typically something like invalid
573 format from opening up the .o files. */
574 bfd_set_error (bfd_error_no_error);
575 lang_clear_os_map ();
576 lang_for_each_statement (build_link_order);
577
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))
582 {
583 /* If there was an error recorded, print it out. Otherwise assume
584 an appropriate error message like unknown symbol was printed
585 out. */
586
587 if (bfd_get_error () != bfd_error_no_error)
588 einfo (_("%F%P: final link failed: %E\n"));
589 else
590 xexit (1);
591 }
592 }
593