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
6This file is part of GLD, the Gnu Linker.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 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
38static void
39build_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
293static bfd_boolean
294unsplittable_name (const char *name)
295{
296  if (CONST_STRNEQ (name, ".stab"))
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
314static asection *
315clone_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 (CONST_STRNEQ (name, ".stab")
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
381static void
382ds (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
401dump (char *s, asection *a1, asection *a2)
402{
403  printf ("%s\n", s);
404  ds (a1);
405  ds (a2);
406}
407
408static void
409sanity_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
431static void
432split_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
546void
547ldwrite (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}
569