[deliverable/binutils-gdb.git] / ld / ldwrite.c

/* ldwrite.c -- write out the linked file
   Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 2000
   Free Software Foundation, Inc.
   Written by Steve Chamberlain sac@cygnus.com

This file is part of GLD, the Gnu Linker.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
#include "libiberty.h"

#include "ld.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldwrite.h"
#include "ldmisc.h"
#include "ldgram.h"
#include "ldmain.h"

static void build_link_order PARAMS ((lang_statement_union_type *));
static asection *clone_section PARAMS ((bfd *, asection *, const char *, int *));
static void split_sections PARAMS ((bfd *, struct bfd_link_info *));

/* Build link_order structures for the BFD linker.  */

static void
build_link_order (statement)
     lang_statement_union_type *statement;
{
  switch (statement->header.type)
    {
    case lang_data_statement_enum:
      {
	asection *output_section;
	struct bfd_link_order *link_order;
	bfd_vma value;
	boolean big_endian = false;

	output_section = statement->data_statement.output_section;
	ASSERT (output_section->owner == output_bfd);

	link_order = bfd_new_link_order (output_bfd, output_section);
	if (link_order == NULL)
	  einfo (_("%P%F: bfd_new_link_order failed\n"));

	link_order->type = bfd_data_link_order;
	link_order->offset = statement->data_statement.output_vma;
	link_order->u.data.contents = (bfd_byte *) xmalloc (QUAD_SIZE);

	value = statement->data_statement.value;

	/* If the endianness of the output BFD is not known, then we
	   base the endianness of the data on the first input file.
	   By convention, the bfd_put routines for an unknown
	   endianness are big endian, so we must swap here if the
	   input file is little endian.  */
	if (bfd_big_endian (output_bfd))
	  big_endian = true;
	else if (bfd_little_endian (output_bfd))
	  big_endian = false;
	else
	  {
	    boolean swap;

	    swap = false;
	    if (command_line.endian == ENDIAN_BIG)
	      big_endian = true;
	    else if (command_line.endian == ENDIAN_LITTLE)
	      {
		big_endian = false;
		swap = true;
	      }
	    else if (command_line.endian == ENDIAN_UNSET)
	      {
		big_endian = true;
		{
		  LANG_FOR_EACH_INPUT_STATEMENT (s)
		    {
		      if (s->the_bfd != NULL)
			{
			  if (bfd_little_endian (s->the_bfd))
			    {
			      big_endian = false;
			      swap = true;
			    }
			  break;
			}
		    }
		}
	      }

	    if (swap)
	      {
		bfd_byte buffer[8];

		switch (statement->data_statement.type)
		  {
		  case QUAD:
		  case SQUAD:
		    if (sizeof (bfd_vma) >= QUAD_SIZE)
		      {
			bfd_putl64 (value, buffer);
			value = bfd_getb64 (buffer);
			break;
		      }
		    /* Fall through.  */
		  case LONG:
		    bfd_putl32 (value, buffer);
		    value = bfd_getb32 (buffer);
		    break;
		  case SHORT:
		    bfd_putl16 (value, buffer);
		    value = bfd_getb16 (buffer);
		    break;
		  case BYTE:
		    break;
		  default:
		    abort ();
		  }
	      }
	  }

	ASSERT (output_section->owner == output_bfd);
	switch (statement->data_statement.type)
	  {
	  case QUAD:
	  case SQUAD:
	    if (sizeof (bfd_vma) >= QUAD_SIZE)
	      bfd_put_64 (output_bfd, value, link_order->u.data.contents);
	    else
	      {
		bfd_vma high;

		if (statement->data_statement.type == QUAD)
		  high = 0;
		else if ((value & 0x80000000) == 0)
		  high = 0;
		else
		  high = (bfd_vma) -1;
		bfd_put_32 (output_bfd, high,
			    (link_order->u.data.contents
			     + (big_endian ? 0 : 4)));
		bfd_put_32 (output_bfd, value,
			    (link_order->u.data.contents
			     + (big_endian ? 4 : 0)));
	      }
	    link_order->size = QUAD_SIZE;
	    break;
	  case LONG:
	    bfd_put_32 (output_bfd, value, link_order->u.data.contents);
	    link_order->size = LONG_SIZE;
	    break;
	  case SHORT:
	    bfd_put_16 (output_bfd, value, link_order->u.data.contents);
	    link_order->size = SHORT_SIZE;
	    break;
	  case BYTE:
	    bfd_put_8 (output_bfd, value, link_order->u.data.contents);
	    link_order->size = BYTE_SIZE;
	    break;
	  default:
	    abort ();
	  }
      }
      break;

    case lang_reloc_statement_enum:
      {
	lang_reloc_statement_type *rs;
	asection *output_section;
	struct bfd_link_order *link_order;

	rs = &statement->reloc_statement;

	output_section = rs->output_section;
	ASSERT (output_section->owner == output_bfd);

	link_order = bfd_new_link_order (output_bfd, output_section);
	if (link_order == NULL)
	  einfo (_("%P%F: bfd_new_link_order failed\n"));

	link_order->offset = rs->output_vma;
	link_order->size = bfd_get_reloc_size (rs->howto);

	link_order->u.reloc.p =
	  ((struct bfd_link_order_reloc *)
	   xmalloc (sizeof (struct bfd_link_order_reloc)));

	link_order->u.reloc.p->reloc = rs->reloc;
	link_order->u.reloc.p->addend = rs->addend_value;

	if (rs->name == NULL)
	  {
	    link_order->type = bfd_section_reloc_link_order;
	    if (rs->section->owner == output_bfd)
	      link_order->u.reloc.p->u.section = rs->section;
	    else
	      {
		link_order->u.reloc.p->u.section = rs->section->output_section;
		link_order->u.reloc.p->addend += rs->section->output_offset;
	      }
	  }
	else
	  {
	    link_order->type = bfd_symbol_reloc_link_order;
	    link_order->u.reloc.p->u.name = rs->name;
	  }
      }
      break;

    case lang_input_section_enum:
      /* Create a new link_order in the output section with this
	 attached */
      if (statement->input_section.ifile->just_syms_flag == false)
	{
	  asection *i = statement->input_section.section;
	  asection *output_section = i->output_section;

	  ASSERT (output_section->owner == output_bfd);

	  if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
	    {
	      struct bfd_link_order *link_order;

	      link_order = bfd_new_link_order (output_bfd, output_section);

	      if (i->flags & SEC_NEVER_LOAD)
		{
		  /* We've got a never load section inside one which
		     is going to be output, we'll change it into a
		     fill link_order */
		  link_order->type = bfd_fill_link_order;
		  link_order->u.fill.value = 0;
		}
	      else
		{
		  link_order->type = bfd_indirect_link_order;
		  link_order->u.indirect.section = i;
		  ASSERT (i->output_section == output_section);
		}
	      if (i->_cooked_size)
		link_order->size = i->_cooked_size;
	      else
		link_order->size = bfd_get_section_size_before_reloc (i);
	      link_order->offset = i->output_offset;
	    }
	}
      break;

    case lang_padding_statement_enum:
      /* Make a new link_order with the right filler */
      {
	asection *output_section;
	struct bfd_link_order *link_order;

	output_section = statement->padding_statement.output_section;
	ASSERT (statement->padding_statement.output_section->owner
		== output_bfd);
	if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
	  {
	    link_order = bfd_new_link_order (output_bfd, output_section);
	    link_order->type = bfd_fill_link_order;
	    link_order->size = statement->padding_statement.size;
	    link_order->offset = statement->padding_statement.output_offset;
	    link_order->u.fill.value = statement->padding_statement.fill;
	  }
      }
      break;

    default:
      /* All the other ones fall through */
      break;
    }
}

/* Call BFD to write out the linked file.  */


/**********************************************************************/


/* Wander around the input sections, make sure that
   we'll never try and create an output section with more relocs
   than will fit.. Do this by always assuming the worst case, and
   creating new output sections with all the right bits.  */
#define TESTIT 1
static asection *
clone_section (abfd, s, name, count)
     bfd *abfd;
     asection *s;
     const char *name;
     int *count;
{
  char templ[6];
  char *sname;
  asection *n;
  struct bfd_link_hash_entry *h;

  /* Invent a section name from the first five chars of the base
     section name and a digit suffix.  */
  strncpy (templ, name, sizeof (templ) - 1);
  templ[sizeof (templ) - 1] = '\0';
  if ((sname = bfd_get_unique_section_name (abfd, templ, count)) == NULL
      || (n = bfd_make_section_anyway (abfd, sname)) == NULL
      || (h = bfd_link_hash_lookup (link_info.hash,
				    sname, true, true, false)) == NULL)
    {
      einfo (_("%F%P: clone section failed: %E\n"));
      /* Silence gcc warnings.  einfo exits, so we never reach here.  */
      return NULL;
    }

  /* Set up section symbol.  */
  h->type = bfd_link_hash_defined;
  h->u.def.value = 0;
  h->u.def.section = n;

  n->flags = s->flags;
  n->vma = s->vma;
  n->user_set_vma = s->user_set_vma;
  n->lma = s->lma;
  n->_cooked_size = 0;
  n->_raw_size = 0;
  n->output_offset = s->output_offset;
  n->output_section = n;
  n->orelocation = 0;
  n->reloc_count = 0;
  n->alignment_power = s->alignment_power;
  return n;
}

#if TESTING
static void 
ds (s)
     asection *s;
{
  struct bfd_link_order *l = s->link_order_head;
  printf ("vma %x size %x\n", s->vma, s->_raw_size);
  while (l)
    {
      if (l->type == bfd_indirect_link_order)
	{
	  printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
	}
      else
	{
	  printf (_("%8x something else\n"), l->offset);
	}
      l = l->next;
    }
  printf ("\n");
}
dump (s, a1, a2)
     char *s;
     asection *a1;
     asection *a2;
{
  printf ("%s\n", s);
  ds (a1);
  ds (a2);
}

static void 
sanity_check (abfd)
     bfd *abfd;
{
  asection *s;
  for (s = abfd->sections; s; s = s->next)
    {
      struct bfd_link_order *p;
      bfd_vma prev = 0;
      for (p = s->link_order_head; p; p = p->next)
	{
	  if (p->offset > 100000)
	    abort ();
	  if (p->offset < prev)
	    abort ();
	  prev = p->offset;
	}
    }
}
#else
#define sanity_check(a)
#define dump(a, b, c)
#endif

static void 
split_sections (abfd, info)
     bfd *abfd;
     struct bfd_link_info *info;
{
  asection *original_sec;
  int nsecs = abfd->section_count;
  sanity_check (abfd);
  /* Look through all the original sections.  */
  for (original_sec = abfd->sections;
       original_sec && nsecs;
       original_sec = original_sec->next, nsecs--)
    {
      int count = 0;
      unsigned int lines = 0;
      unsigned int relocs = 0;
      bfd_size_type sec_size = 0;
      struct bfd_link_order *l;
      struct bfd_link_order *p;
      bfd_vma vma = original_sec->vma;
      asection *cursor = original_sec;

      /* Count up the relocations and line entries to see if anything
	 would be too big to fit.  Accumulate section size too.  */
      for (l = NULL, p = cursor->link_order_head; p != NULL; p = l->next)
	{
	  unsigned int thislines = 0;
	  unsigned int thisrelocs = 0;
	  bfd_size_type thissize = 0;
	  if (p->type == bfd_indirect_link_order)
	    {
	      asection *sec;

	      sec = p->u.indirect.section;

	      if (info->strip == strip_none
		  || info->strip == strip_some)
		thislines = sec->lineno_count;

	      if (info->relocateable)
		thisrelocs = sec->reloc_count;

	      if (sec->_cooked_size != 0)
		thissize = sec->_cooked_size;
	      else
		thissize = sec->_raw_size;

	    }
	  else if (info->relocateable
		   && (p->type == bfd_section_reloc_link_order
		       || p->type == bfd_symbol_reloc_link_order))
	    thisrelocs++;

	  if (l != NULL
	      && (thisrelocs + relocs >= config.split_by_reloc
		  || thislines + lines >= config.split_by_reloc
		  || thissize + sec_size >= config.split_by_file))
	    {
	      /* Create a new section and put this link order and the
		 following link orders into it.  */
	      bfd_vma shift_offset;
	      asection *n;

	      n = clone_section (abfd, cursor, original_sec->name, &count);

	      /* Attach the link orders to the new section and snip
		 them off from the old section.  */
	      n->link_order_head = p;
	      n->link_order_tail = cursor->link_order_tail;
	      cursor->link_order_tail = l;
	      l->next = NULL;
	      l = p;

	      /* Change the size of the original section and
		 update the vma of the new one.  */

	      dump ("before snip", cursor, n);

	      shift_offset = p->offset;
	      if (cursor->_cooked_size != 0)
		{
		  n->_cooked_size = cursor->_cooked_size - shift_offset;
		  cursor->_cooked_size = shift_offset;
		}
	      n->_raw_size = cursor->_raw_size - shift_offset;
	      cursor->_raw_size = shift_offset;

	      vma += shift_offset;
	      n->lma = n->vma = vma;

	      /* Run down the chain and change the output section to
		 the right one, update the offsets too.  */
	      do
		{
		  p->offset -= shift_offset;
		  if (p->type == bfd_indirect_link_order)
		    {
		      p->u.indirect.section->output_section = n;
		      p->u.indirect.section->output_offset = p->offset;
		    }
		  p = p->next;
		}
	      while (p);

	      dump ("after snip", cursor, n);
	      cursor = n;
	      relocs = thisrelocs;
	      lines = thislines;
	      sec_size = thissize;
	    }
	  else
	    {
	      l = p;
	      relocs += thisrelocs;
	      lines += thislines;
	      sec_size += thissize;
	    }
	}
    }
  sanity_check (abfd);
}
/**********************************************************************/
void
ldwrite ()
{
  /* Reset error indicator, which can typically something like invalid
     format from opening up the .o files.  */
  bfd_set_error (bfd_error_no_error);
  lang_for_each_statement (build_link_order);

  if (config.split_by_reloc != (unsigned) -1
      || config.split_by_file != (bfd_size_type) -1)
    split_sections (output_bfd, &link_info);
  if (!bfd_final_link (output_bfd, &link_info))
    {
      /* If there was an error recorded, print it out.  Otherwise assume
	 an appropriate error message like unknown symbol was printed
	 out.  */

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