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