Update year range in copyright notice of all files.
[external/binutils.git] / ld / ldwrite.c
1 /* ldwrite.c -- write out the linked file
2    Copyright (C) 1991-2017 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
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
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 *
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
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         printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
413       else
414         printf (_("%8x something else\n"), l->offset);
415       l = l->next;
416     }
417   printf ("\n");
418 }
419
420 dump (char *s, asection *a1, asection *a2)
421 {
422   printf ("%s\n", s);
423   ds (a1);
424   ds (a2);
425 }
426
427 static void
428 sanity_check (bfd *abfd)
429 {
430   asection *s;
431   for (s = abfd->sections; s; s = s->next)
432     {
433       struct bfd_link_order *p;
434       bfd_vma prev = 0;
435       for (p = s->map_head.link_order; p; p = p->next)
436         {
437           if (p->offset > 100000)
438             abort ();
439           if (p->offset < prev)
440             abort ();
441           prev = p->offset;
442         }
443     }
444 }
445 #else
446 #define sanity_check(a)
447 #define dump(a, b, c)
448 #endif
449
450 static void
451 split_sections (bfd *abfd, struct bfd_link_info *info)
452 {
453   asection *original_sec;
454   int nsecs = abfd->section_count;
455   sanity_check (abfd);
456   /* Look through all the original sections.  */
457   for (original_sec = abfd->sections;
458        original_sec && nsecs;
459        original_sec = original_sec->next, nsecs--)
460     {
461       int count = 0;
462       unsigned int lines = 0;
463       unsigned int relocs = 0;
464       bfd_size_type sec_size = 0;
465       struct bfd_link_order *l;
466       struct bfd_link_order *p;
467       bfd_vma vma = original_sec->vma;
468       asection *cursor = original_sec;
469
470       /* Count up the relocations and line entries to see if anything
471          would be too big to fit.  Accumulate section size too.  */
472       for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next)
473         {
474           unsigned int thislines = 0;
475           unsigned int thisrelocs = 0;
476           bfd_size_type thissize = 0;
477           if (p->type == bfd_indirect_link_order)
478             {
479               asection *sec;
480
481               sec = p->u.indirect.section;
482
483               if (info->strip == strip_none
484                   || info->strip == strip_some)
485                 thislines = sec->lineno_count;
486
487               if (bfd_link_relocatable (info))
488                 thisrelocs = sec->reloc_count;
489
490               thissize = sec->size;
491
492             }
493           else if (bfd_link_relocatable (info)
494                    && (p->type == bfd_section_reloc_link_order
495                        || p->type == bfd_symbol_reloc_link_order))
496             thisrelocs++;
497
498           if (l != NULL
499               && (thisrelocs + relocs >= config.split_by_reloc
500                   || thislines + lines >= config.split_by_reloc
501                   || (thissize + sec_size >= config.split_by_file))
502               && !unsplittable_name (cursor->name))
503             {
504               /* Create a new section and put this link order and the
505                  following link orders into it.  */
506               bfd_vma shift_offset;
507               asection *n;
508
509               n = clone_section (abfd, cursor, original_sec->name, &count);
510
511               /* Attach the link orders to the new section and snip
512                  them off from the old section.  */
513               n->map_head.link_order = p;
514               n->map_tail.link_order = cursor->map_tail.link_order;
515               cursor->map_tail.link_order = l;
516               l->next = NULL;
517               l = p;
518
519               /* Change the size of the original section and
520                  update the vma of the new one.  */
521
522               dump ("before snip", cursor, n);
523
524               shift_offset = p->offset;
525               n->size = cursor->size - shift_offset;
526               cursor->size = shift_offset;
527
528               vma += shift_offset;
529               n->lma = n->vma = vma;
530
531               /* Run down the chain and change the output section to
532                  the right one, update the offsets too.  */
533               do
534                 {
535                   p->offset -= shift_offset;
536                   if (p->type == bfd_indirect_link_order)
537                     {
538                       p->u.indirect.section->output_section = n;
539                       p->u.indirect.section->output_offset = p->offset;
540                     }
541                   p = p->next;
542                 }
543               while (p);
544
545               dump ("after snip", cursor, n);
546               cursor = n;
547               relocs = thisrelocs;
548               lines = thislines;
549               sec_size = thissize;
550             }
551           else
552             {
553               l = p;
554               relocs += thisrelocs;
555               lines += thislines;
556               sec_size += thissize;
557             }
558         }
559     }
560   sanity_check (abfd);
561 }
562
563 /* Call BFD to write out the linked file.  */
564
565 void
566 ldwrite (void)
567 {
568   /* Reset error indicator, which can typically something like invalid
569      format from opening up the .o files.  */
570   bfd_set_error (bfd_error_no_error);
571   lang_clear_os_map ();
572   lang_for_each_statement (build_link_order);
573
574   if (config.split_by_reloc != (unsigned) -1
575       || config.split_by_file != (bfd_size_type) -1)
576     split_sections (link_info.output_bfd, &link_info);
577   if (!bfd_final_link (link_info.output_bfd, &link_info))
578     {
579       /* If there was an error recorded, print it out.  Otherwise assume
580          an appropriate error message like unknown symbol was printed
581          out.  */
582
583       if (bfd_get_error () != bfd_error_no_error)
584         einfo (_("%F%P: final link failed: %E\n"));
585       else
586         xexit (1);
587     }
588 }