Upload Tizen:Base source
[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, 2006, 2007, 2008, 2010
4    Free Software Foundation, Inc.
5    Written by Steve Chamberlain sac@cygnus.com
6
7    This file is part of the GNU Binutils.
8
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.
13
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.
18
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.  */
23
24 #include "sysdep.h"
25 #include "bfd.h"
26 #include "bfdlink.h"
27 #include "libiberty.h"
28 #include "safe-ctype.h"
29
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"
37
38 /* Build link_order structures for the BFD linker.  */
39
40 static void
41 build_link_order (lang_statement_union_type *statement)
42 {
43   switch (statement->header.type)
44     {
45     case lang_data_statement_enum:
46       {
47         asection *output_section;
48         struct bfd_link_order *link_order;
49         bfd_vma value;
50         bfd_boolean big_endian = FALSE;
51
52         output_section = statement->data_statement.output_section;
53         ASSERT (output_section->owner == link_info.output_bfd);
54
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;
59
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"));
63
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);
67
68         value = statement->data_statement.value;
69
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
80           {
81             bfd_boolean swap;
82
83             swap = FALSE;
84             if (command_line.endian == ENDIAN_BIG)
85               big_endian = TRUE;
86             else if (command_line.endian == ENDIAN_LITTLE)
87               {
88                 big_endian = FALSE;
89                 swap = TRUE;
90               }
91             else if (command_line.endian == ENDIAN_UNSET)
92               {
93                 big_endian = TRUE;
94                 {
95                   LANG_FOR_EACH_INPUT_STATEMENT (s)
96                     {
97                       if (s->the_bfd != NULL)
98                         {
99                           if (bfd_little_endian (s->the_bfd))
100                             {
101                               big_endian = FALSE;
102                               swap = TRUE;
103                             }
104                           break;
105                         }
106                     }
107                 }
108               }
109
110             if (swap)
111               {
112                 bfd_byte buffer[8];
113
114                 switch (statement->data_statement.type)
115                   {
116                   case QUAD:
117                   case SQUAD:
118                     if (sizeof (bfd_vma) >= QUAD_SIZE)
119                       {
120                         bfd_putl64 (value, buffer);
121                         value = bfd_getb64 (buffer);
122                         break;
123                       }
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 ();
137                   }
138               }
139           }
140
141         ASSERT (output_section->owner == link_info.output_bfd);
142         switch (statement->data_statement.type)
143           {
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
150               {
151                 bfd_vma high;
152
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)));
165               }
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 ();
185           }
186       }
187       break;
188
189     case lang_reloc_statement_enum:
190       {
191         lang_reloc_statement_type *rs;
192         asection *output_section;
193         struct bfd_link_order *link_order;
194
195         rs = &statement->reloc_statement;
196
197         output_section = rs->output_section;
198         ASSERT (output_section->owner == link_info.output_bfd);
199
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;
204
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"));
208
209         link_order->offset = rs->output_offset;
210         link_order->size = bfd_get_reloc_size (rs->howto);
211
212         link_order->u.reloc.p = (struct bfd_link_order_reloc *)
213             xmalloc (sizeof (struct bfd_link_order_reloc));
214
215         link_order->u.reloc.p->reloc = rs->reloc;
216         link_order->u.reloc.p->addend = rs->addend_value;
217
218         if (rs->name == NULL)
219           {
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
224               {
225                 link_order->u.reloc.p->u.section = rs->section->output_section;
226                 link_order->u.reloc.p->addend += rs->section->output_offset;
227               }
228           }
229         else
230           {
231             link_order->type = bfd_symbol_reloc_link_order;
232             link_order->u.reloc.p->u.name = rs->name;
233           }
234       }
235       break;
236
237     case lang_input_section_enum:
238       {
239         /* Create a new link_order in the output section with this
240            attached */
241         asection *i = statement->input_section.section;
242
243         if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
244             && (i->flags & SEC_EXCLUDE) == 0)
245           {
246             asection *output_section = i->output_section;
247             struct bfd_link_order *link_order;
248
249             ASSERT (output_section->owner == link_info.output_bfd);
250
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;
255
256             link_order = bfd_new_link_order (link_info.output_bfd,
257                                              output_section);
258
259             if ((i->flags & SEC_NEVER_LOAD) != 0
260                 && (i->flags & SEC_DEBUGGING) == 0)
261               {
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;
267               }
268             else
269               {
270                 link_order->type = bfd_indirect_link_order;
271                 link_order->u.indirect.section = i;
272                 ASSERT (i->output_section == output_section);
273               }
274             link_order->size = i->size;
275             link_order->offset = i->output_offset;
276           }
277       }
278       break;
279
280     case lang_padding_statement_enum:
281       /* Make a new link_order with the right filler */
282       {
283         asection *output_section;
284         struct bfd_link_order *link_order;
285
286         output_section = statement->padding_statement.output_section;
287         ASSERT (statement->padding_statement.output_section->owner
288                 == link_info.output_bfd);
289
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;
294
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;
302       }
303       break;
304
305     default:
306       /* All the other ones fall through */
307       break;
308     }
309 }
310
311 /* Return true if NAME is the name of an unsplittable section. These
312    are the stabs strings, dwarf strings.  */
313
314 static bfd_boolean
315 unsplittable_name (const char *name)
316 {
317   if (CONST_STRNEQ (name, ".stab"))
318     {
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;
324     }
325   else if (strcmp (name, "$GDB_STRINGS$") == 0)
326     return TRUE;
327   return FALSE;
328 }
329
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)
337 {
338   char *tname;
339   char *sname;
340   unsigned int len;     
341   asection *n;
342   struct bfd_link_hash_entry *h;
343
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;
355
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)
359     {
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)
364         {
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;
368         }
369       tname[5] = 0;
370     }
371
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)
376     {
377       einfo (_("%F%P: clone section failed: %E\n"));
378       /* Silence gcc warnings.  einfo exits, so we never reach here.  */
379       return NULL;
380     }
381   free (tname);
382
383   /* Set up section symbol.  */
384   h->type = bfd_link_hash_defined;
385   h->u.def.value = 0;
386   h->u.def.section = n;
387
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;
398
399   bfd_copy_private_section_data (abfd, s, abfd, n);
400
401   return n;
402 }
403
404 #if TESTING
405 static void
406 ds (asection *s)
407 {
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)
411     {
412       if (l->type == bfd_indirect_link_order)
413         {
414           printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
415         }
416       else
417         {
418           printf (_("%8x something else\n"), l->offset);
419         }
420       l = l->next;
421     }
422   printf ("\n");
423 }
424
425 dump (char *s, asection *a1, asection *a2)
426 {
427   printf ("%s\n", s);
428   ds (a1);
429   ds (a2);
430 }
431
432 static void
433 sanity_check (bfd *abfd)
434 {
435   asection *s;
436   for (s = abfd->sections; s; s = s->next)
437     {
438       struct bfd_link_order *p;
439       bfd_vma prev = 0;
440       for (p = s->map_head.link_order; p; p = p->next)
441         {
442           if (p->offset > 100000)
443             abort ();
444           if (p->offset < prev)
445             abort ();
446           prev = p->offset;
447         }
448     }
449 }
450 #else
451 #define sanity_check(a)
452 #define dump(a, b, c)
453 #endif
454
455 static void
456 split_sections (bfd *abfd, struct bfd_link_info *info)
457 {
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--)
465     {
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;
474
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)
478         {
479           unsigned int thislines = 0;
480           unsigned int thisrelocs = 0;
481           bfd_size_type thissize = 0;
482           if (p->type == bfd_indirect_link_order)
483             {
484               asection *sec;
485
486               sec = p->u.indirect.section;
487
488               if (info->strip == strip_none
489                   || info->strip == strip_some)
490                 thislines = sec->lineno_count;
491
492               if (info->relocatable)
493                 thisrelocs = sec->reloc_count;
494
495               thissize = sec->size;
496
497             }
498           else if (info->relocatable
499                    && (p->type == bfd_section_reloc_link_order
500                        || p->type == bfd_symbol_reloc_link_order))
501             thisrelocs++;
502
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))
508             {
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;
513
514               n = clone_section (abfd, cursor, original_sec->name, &count);
515
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;
523
524               /* Change the size of the original section and
525                  update the vma of the new one.  */
526
527               dump ("before snip", cursor, n);
528
529               shift_offset = p->offset;
530               n->size = cursor->size - shift_offset;
531               cursor->size = shift_offset;
532
533               vma += shift_offset;
534               n->lma = n->vma = vma;
535
536               /* Run down the chain and change the output section to
537                  the right one, update the offsets too.  */
538               do
539                 {
540                   p->offset -= shift_offset;
541                   if (p->type == bfd_indirect_link_order)
542                     {
543                       p->u.indirect.section->output_section = n;
544                       p->u.indirect.section->output_offset = p->offset;
545                     }
546                   p = p->next;
547                 }
548               while (p);
549
550               dump ("after snip", cursor, n);
551               cursor = n;
552               relocs = thisrelocs;
553               lines = thislines;
554               sec_size = thissize;
555             }
556           else
557             {
558               l = p;
559               relocs += thisrelocs;
560               lines += thislines;
561               sec_size += thissize;
562             }
563         }
564     }
565   sanity_check (abfd);
566 }
567
568 /* Call BFD to write out the linked file.  */
569
570 void
571 ldwrite (void)
572 {
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);
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 }