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