[binutils.git] / ld / ldwrite.c

/* ldwrite.c -- write out the linked file
   Copyright (C) 1993 Free Software Foundation, Inc.
   Written by Steve Chamberlain [email protected]

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 "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 void print_symbol_table PARAMS ((void));
static void print_file_stuff PARAMS ((lang_input_statement_type *));
static boolean print_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));

extern char *strdup();

/* 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;

	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)
	    && ! bfd_little_endian (output_bfd))
	  {
	    boolean swap;

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

	    if (swap)
	      {
		bfd_byte buffer[8];

		switch (statement->data_statement.type)
		  {
		  case QUAD:
		    bfd_putl64 (value, buffer);
		    value = bfd_getb64 (buffer);
		    break;
		  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:
	    bfd_put_64 (output_bfd, value, link_order->u.data.contents);
	    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, count)
     bfd *abfd;
     asection *s;
     int *count;
{
#define SSIZE 8
  char sname[SSIZE];		/* ??  find the name for this size */
  asection *n;
  struct bfd_link_hash_entry *h;
  /* Invent a section name - use first five
     chars of base section name and a digit suffix */
  do
    {
      unsigned int i;
      char b[6];
      for (i = 0; i < sizeof (b) - 1 && s->name[i]; i++)
	b[i] = s->name[i];
      b[i] = 0;
      sprintf (sname, "%s%d", b, (*count)++);
    }
  while (bfd_get_section_by_name (abfd, sname));

  n = bfd_make_section_anyway (abfd, strdup (sname));

  /* Create a symbol of the same name */

  h = bfd_link_hash_lookup (link_info.hash,
			    sname, true, true, false);
  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


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--)
    {
      boolean first = true;
      int count = 0;
      int lines = 0;
      int relocs = 0;
      struct bfd_link_order **pp;
      bfd_vma vma = original_sec->vma;
      bfd_vma shift_offset = 0;
      asection *cursor = original_sec;

      /* count up the relocations and line entries to see if
	 anything would be too big to fit */
      for (pp = &(cursor->link_order_head); *pp; pp = &((*pp)->next))
	{
	  struct bfd_link_order *p = *pp;
	  int thislines = 0;
	  int thisrelocs = 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;

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

	  if (! first
	      && (thisrelocs + relocs > config.split_by_reloc
		  || thislines + lines > config.split_by_reloc
		  || config.split_by_file))
	    {
	      /* create a new section and put this link order and the
		 following link orders into it */
	      struct bfd_link_order *l = p;
	      asection *n = clone_section (abfd, cursor, &count);
	      *pp = NULL;	/* Snip off link orders from old section */
	      n->link_order_head = l;	/* attach to new section */
	      pp = &n->link_order_head;

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

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

	      n->_raw_size = cursor->_raw_size - l->offset;
	      cursor->_raw_size = l->offset;

	      vma += cursor->_raw_size;
	      n->lma = n->vma = vma;

	      shift_offset = l->offset;

	      /* run down the chain and change the output section to
		 the right one, update the offsets too */

	      while (l)
		{
		  l->offset -= shift_offset;
		  if (l->type == bfd_indirect_link_order)
		    {
		      l->u.indirect.section->output_section = n;
		      l->u.indirect.section->output_offset = l->offset;
		    }
		  l = l->next;
		}
	      dump ("after snip", cursor, n);
	      cursor = n;
	      relocs = thisrelocs;
	      lines = thislines;
	    }
	  else
	    {
	      relocs += thisrelocs;
	      lines += thislines;
	    }

	  first = false;
	}
    }
  sanity_check (abfd);
}
/**********************************************************************/
void
ldwrite ()
{
  /* Reset error indicator, which can typically something like invalid
     format from openning up the .o files */
  bfd_set_error (bfd_error_no_error);
  lang_for_each_statement (build_link_order);

  if (config.split_by_reloc || config.split_by_file)
    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", output_bfd);
      else
	xexit(1);
    }

  if (config.map_file)
    {
      print_symbol_table ();
      lang_map ();
    }
}

/* Print the symbol table.  */

static void
print_symbol_table ()
{
  fprintf (config.map_file, "\n**FILES**\n\n");
  lang_for_each_file (print_file_stuff);

  fprintf (config.map_file, "**GLOBAL SYMBOLS**\n\n");
  fprintf (config.map_file, "offset    section    offset   symbol\n");
  bfd_link_hash_traverse (link_info.hash, print_symbol, (PTR) NULL);
}

/* Print information about a file.  */

static void
print_file_stuff (f)
     lang_input_statement_type *f;
{
  fprintf (config.map_file, "  %s\n", f->filename);
  if (f->just_syms_flag)
    {
      fprintf (config.map_file, " symbols only\n");
    }
  else
    {
      asection *s;
      if (true)
	{
	  for (s = f->the_bfd->sections;
	       s != (asection *) NULL;
	       s = s->next)
	    {
#ifdef WINDOWS_NT
              /* Don't include any information that goes into the '.junk'
                 section.  This includes the code view .debug$ data and
                 stuff from .drectve sections */
              if (strcmp (s->name, ".drectve") == 0 ||
                  strncmp (s->name, ".debug$", 7) == 0)
                continue;
#endif
	      print_address (s->output_offset);
	      if (s->reloc_done)
		{
		  fprintf (config.map_file, " %08x 2**%2ud %s\n",
			   (unsigned) bfd_get_section_size_after_reloc (s),
			   s->alignment_power, s->name);
		}

	      else
		{
		  fprintf (config.map_file, " %08x 2**%2ud %s\n",
			   (unsigned) bfd_get_section_size_before_reloc (s),
			   s->alignment_power, s->name);
		}
	    }
	}
      else
	{
	  for (s = f->the_bfd->sections;
	       s != (asection *) NULL;
	       s = s->next)
	    {
	      fprintf (config.map_file, "%s ", s->name);
	      print_address (s->output_offset);
	      fprintf (config.map_file, "(%x)",
		       (unsigned) bfd_get_section_size_after_reloc (s));
	    }
	  fprintf (config.map_file, "hex \n");
	}
    }
  print_nl ();
}

/* Print a symbol.  */

/*ARGSUSED*/
static boolean
print_symbol (p, ignore)
     struct bfd_link_hash_entry *p;
     PTR ignore;
{
  while (p->type == bfd_link_hash_indirect
	 || p->type == bfd_link_hash_warning)
    p = p->u.i.link;

  switch (p->type)
    {
    case bfd_link_hash_new:
      abort ();

    case bfd_link_hash_undefined:
      fprintf (config.map_file, "undefined                     ");
      fprintf (config.map_file, "%s ", p->root.string);
      print_nl ();
      break;

    case bfd_link_hash_undefweak:
      fprintf (config.map_file, "weak                          ");
      fprintf (config.map_file, "%s ", p->root.string);
      print_nl ();
      break;

    case bfd_link_hash_defined:
    case bfd_link_hash_defweak:
      {
	asection *defsec = p->u.def.section;

	print_address (p->u.def.value);
	if (defsec)
	  {
	    fprintf (config.map_file, "  %-10s",
		     bfd_section_name (output_bfd, defsec));
	    print_space ();
	    print_address (p->u.def.value + defsec->vma);
	  }
	else
	  {
	    fprintf (config.map_file, "         .......");
	  }
	fprintf (config.map_file, " %s", p->root.string);
	if (p->type == bfd_link_hash_defweak)
	  fprintf (config.map_file, " [weak]");
      }
      print_nl ();
      break;

    case bfd_link_hash_common:
      fprintf (config.map_file, "common               ");
      print_address (p->u.c.size);
      fprintf (config.map_file, " %s ", p->root.string);
      print_nl ();
      break;

    default:
      abort ();
    }

  return true;
}
Commit	Line	Data
4a6afc88 ILT	1	/* ldwrite.c -- write out the linked file
	2	Copyright (C) 1993 Free Software Foundation, Inc.
	3	Written by Steve Chamberlain [email protected]
fcf276c4	4
2fa0b342 DHW	5	This file is part of GLD, the Gnu Linker.
2fa0b342 DHW	6
2e2bf962	7	This program is free software; you can redistribute it and/or modify
2fa0b342	8	it under the terms of the GNU General Public License as published by
2e2bf962 SC	9	the Free Software Foundation; either version 2 of the License, or
2e2bf962 SC	10	(at your option) any later version.
2fa0b342	11
2e2bf962	12	This program is distributed in the hope that it will be useful,
2fa0b342 DHW	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
2e2bf962	18	along with this program; if not, write to the Free Software
242eee7a	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
2fa0b342	20
2fa0b342	21	#include "bfd.h"
2e2bf962	22	#include "sysdep.h"
4a6afc88	23	#include "bfdlink.h"
2fa0b342	24
2fa0b342	25	#include "ld.h"
fcf276c4 ILT	26	#include "ldexp.h"
fcf276c4 ILT	27	#include "ldlang.h"
2fa0b342 DHW	28	#include "ldwrite.h"
2fa0b342 DHW	29	#include "ldmisc.h"
2e2bf962	30	#include "ldgram.h"
fcf276c4	31	#include "ldmain.h"
4a6afc88 ILT	32
	33	static void build_link_order PARAMS ((lang_statement_union_type *));
	34	static void print_symbol_table PARAMS ((void));
	35	static void print_file_stuff PARAMS ((lang_input_statement_type *));
	36	static boolean print_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
	37
7d6439d9 ILT	38	extern char *strdup();
7d6439d9 ILT	39
4a6afc88	40	/* Build link_order structures for the BFD linker. */
2fa0b342 DHW	41
2fa0b342 DHW	42	static void
4a6afc88 ILT	43	build_link_order (statement)
	44	lang_statement_union_type *statement;
	45	{
	46	switch (statement->header.type)
	47	{
	48	case lang_data_statement_enum:
4a6afc88	49	{
885ae6b9 SC	50	asection *output_section;
	51	struct bfd_link_order *link_order;
	52	bfd_vma value;
	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)
7d6439d9	59	einfo ("%P%F: bfd_new_link_order failed\n");
885ae6b9 SC	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;
4a6afc88	66
efa6c497 ILT	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	&& ! bfd_little_endian (output_bfd))
	74	{
	75	boolean swap;
	76
	77	swap = false;
	78	if (command_line.endian == ENDIAN_LITTLE)
	79	swap = true;
	80	else if (command_line.endian == ENDIAN_UNSET)
	81	{
	82	LANG_FOR_EACH_INPUT_STATEMENT (s)
	83	{
	84	if (s->the_bfd != NULL)
	85	{
	86	if (bfd_little_endian (s->the_bfd))
	87	swap = true;
	88	break;
	89	}
	90	}
	91	}
	92
	93	if (swap)
	94	{
	95	bfd_byte buffer[8];
	96
	97	switch (statement->data_statement.type)
	98	{
	99	case QUAD:
	100	bfd_putl64 (value, buffer);
	101	value = bfd_getb64 (buffer);
	102	break;
	103	case LONG:
	104	bfd_putl32 (value, buffer);
	105	value = bfd_getb32 (buffer);
	106	break;
	107	case SHORT:
	108	bfd_putl16 (value, buffer);
	109	value = bfd_getb16 (buffer);
	110	break;
	111	case BYTE:
	112	break;
	113	default:
	114	abort ();
	115	}
	116	}
	117	}
	118
4a6afc88 ILT	119	ASSERT (output_section->owner == output_bfd);
	120	switch (statement->data_statement.type)
	121	{
4fdbafb2	122	case QUAD:
885ae6b9 SC	123	bfd_put_64 (output_bfd, value, link_order->u.data.contents);
885ae6b9 SC	124	link_order->size = QUAD_SIZE;
4fdbafb2	125	break;
4a6afc88	126	case LONG:
885ae6b9 SC	127	bfd_put_32 (output_bfd, value, link_order->u.data.contents);
885ae6b9 SC	128	link_order->size = LONG_SIZE;
4a6afc88 ILT	129	break;
4a6afc88 ILT	130	case SHORT:
885ae6b9 SC	131	bfd_put_16 (output_bfd, value, link_order->u.data.contents);
885ae6b9 SC	132	link_order->size = SHORT_SIZE;
4a6afc88 ILT	133	break;
4a6afc88 ILT	134	case BYTE:
885ae6b9 SC	135	bfd_put_8 (output_bfd, value, link_order->u.data.contents);
885ae6b9 SC	136	link_order->size = BYTE_SIZE;
4a6afc88 ILT	137	break;
	138	default:
	139	abort ();
	140	}
4a6afc88 ILT	141	}
	142	break;
	143
4fdbafb2 ILT	144	case lang_reloc_statement_enum:
	145	{
	146	lang_reloc_statement_type *rs;
	147	asection *output_section;
	148	struct bfd_link_order *link_order;
	149
	150	rs = &statement->reloc_statement;
	151
	152	output_section = rs->output_section;
	153	ASSERT (output_section->owner == output_bfd);
	154
	155	link_order = bfd_new_link_order (output_bfd, output_section);
	156	if (link_order == NULL)
7d6439d9	157	einfo ("%P%F: bfd_new_link_order failed\n");
4fdbafb2 ILT	158
	159	link_order->offset = rs->output_vma;
	160	link_order->size = bfd_get_reloc_size (rs->howto);
	161
	162	link_order->u.reloc.p =
	163	((struct bfd_link_order_reloc *)
	164	xmalloc (sizeof (struct bfd_link_order_reloc)));
	165
	166	link_order->u.reloc.p->reloc = rs->reloc;
	167	link_order->u.reloc.p->addend = rs->addend_value;
	168
efa6c497	169	if (rs->name == NULL)
4fdbafb2	170	{
4fdbafb2 ILT	171	link_order->type = bfd_section_reloc_link_order;
	172	if (rs->section->owner == output_bfd)
	173	link_order->u.reloc.p->u.section = rs->section;
	174	else
	175	{
	176	link_order->u.reloc.p->u.section = rs->section->output_section;
	177	link_order->u.reloc.p->addend += rs->section->output_offset;
	178	}
	179	}
	180	else
	181	{
4fdbafb2 ILT	182	link_order->type = bfd_symbol_reloc_link_order;
	183	link_order->u.reloc.p->u.name = rs->name;
	184	}
	185	}
	186	break;
	187
4a6afc88 ILT	188	case lang_input_section_enum:
	189	/* Create a new link_order in the output section with this
	190	attached */
	191	if (statement->input_section.ifile->just_syms_flag == false)
	192	{
	193	asection *i = statement->input_section.section;
	194	asection *output_section = i->output_section;
	195
	196	ASSERT (output_section->owner == output_bfd);
	197
	198	if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
	199	{
	200	struct bfd_link_order *link_order;
	201
	202	link_order = bfd_new_link_order (output_bfd, output_section);
	203
	204	if (i->flags & SEC_NEVER_LOAD)
	205	{
	206	/* We've got a never load section inside one which
	207	is going to be output, we'll change it into a
	208	fill link_order */
	209	link_order->type = bfd_fill_link_order;
	210	link_order->u.fill.value = 0;
	211	}
	212	else
	213	{
	214	link_order->type = bfd_indirect_link_order;
	215	link_order->u.indirect.section = i;
	216	ASSERT (i->output_section == output_section);
	217	}
4fdbafb2 ILT	218	if (i->_cooked_size)
	219	link_order->size = i->_cooked_size;
	220	else
	221	link_order->size = bfd_get_section_size_before_reloc (i);
4a6afc88 ILT	222	link_order->offset = i->output_offset;
	223	}
	224	}
	225	break;
	226
	227	case lang_padding_statement_enum:
	228	/* Make a new link_order with the right filler */
	229	{
	230	asection *output_section;
	231	struct bfd_link_order *link_order;
	232
	233	output_section = statement->padding_statement.output_section;
	234	ASSERT (statement->padding_statement.output_section->owner
	235	== output_bfd);
	236	if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
	237	{
	238	link_order = bfd_new_link_order (output_bfd, output_section);
	239	link_order->type = bfd_fill_link_order;
	240	link_order->size = statement->padding_statement.size;
	241	link_order->offset = statement->padding_statement.output_offset;
	242	link_order->u.fill.value = statement->padding_statement.fill;
	243	}
	244	}
	245	break;
	246
	247	default:
	248	/* All the other ones fall through */
	249	break;
	250	}
	251	}
	252
	253	/* Call BFD to write out the linked file. */
	254
885ae6b9 SC	255
	256	/**********************************************************************/
	257
	258
	259	/* Wander around the input sections, make sure that
	260	we'll never try and create an output section with more relocs
	261	than will fit.. Do this by always assuming the worst case, and
	262	creating new output sections with all the right bits */
	263	#define TESTIT 1
	264	static asection *
	265	clone_section (abfd, s, count)
	266	bfd *abfd;
	267	asection *s;
	268	int *count;
	269	{
	270	#define SSIZE 8
	271	char sname[SSIZE]; /* ?? find the name for this size */
	272	asection *n;
242eee7a	273	struct bfd_link_hash_entry *h;
885ae6b9 SC	274	/* Invent a section name - use first five
	275	chars of base section name and a digit suffix */
	276	do
	277	{
7d6439d9	278	unsigned int i;
885ae6b9 SC	279	char b[6];
	280	for (i = 0; i < sizeof (b) - 1 && s->name[i]; i++)
	281	b[i] = s->name[i];
	282	b[i] = 0;
	283	sprintf (sname, "%s%d", b, (*count)++);
	284	}
	285	while (bfd_get_section_by_name (abfd, sname));
	286
	287	n = bfd_make_section_anyway (abfd, strdup (sname));
	288
242eee7a ILT	289	/* Create a symbol of the same name */
	290
	291	h = bfd_link_hash_lookup (link_info.hash,
	292	sname, true, true, false);
	293	h->type = bfd_link_hash_defined;
	294	h->u.def.value = 0;
	295	h->u.def.section = n ;
	296
	297
885ae6b9 SC	298	n->flags = s->flags;
	299	n->vma = s->vma;
	300	n->user_set_vma = s->user_set_vma;
	301	n->lma = s->lma;
	302	n->_cooked_size = 0;
	303	n->_raw_size = 0;
	304	n->output_offset = s->output_offset;
	305	n->output_section = n;
	306	n->orelocation = 0;
	307	n->reloc_count = 0;
7d6439d9	308	n->alignment_power = s->alignment_power;
885ae6b9 SC	309	return n;
	310	}
	311
	312	#if TESTING
	313	static void
	314	ds (s)
	315	asection *s;
	316	{
	317	struct bfd_link_order *l = s->link_order_head;
	318	printf ("vma %x size %x\n", s->vma, s->_raw_size);
	319	while (l)
	320	{
	321	if (l->type == bfd_indirect_link_order)
	322	{
	323	printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
	324	}
	325	else
	326	{
	327	printf ("%8x something else\n", l->offset);
	328	}
	329	l = l->next;
	330	}
	331	printf ("\n");
	332	}
	333	dump (s, a1, a2)
	334	char *s;
	335	asection *a1;
	336	asection *a2;
	337	{
	338	printf ("%s\n", s);
	339	ds (a1);
	340	ds (a2);
	341	}
	342
	343	static void
	344	sanity_check (abfd)
	345	bfd *abfd;
	346	{
	347	asection *s;
	348	for (s = abfd->sections; s; s = s->next)
	349	{
	350	struct bfd_link_order *p;
	351	bfd_vma prev = 0;
	352	for (p = s->link_order_head; p; p = p->next)
	353	{
	354	if (p->offset > 100000)
	355	abort ();
	356	if (p->offset < prev)
	357	abort ();
	358	prev = p->offset;
	359	}
	360	}
	361	}
	362	#else
	363	#define sanity_check(a)
	364	#define dump(a, b, c)
	365	#endif
	366
	367
	368	void
	369	split_sections (abfd, info)
	370	bfd *abfd;
	371	struct bfd_link_info *info;
	372	{
373	asection *original_sec;
374	int nsecs = abfd->section_count;
375	sanity_check (abfd);
376	/* look through all the original sections */
377	for (original_sec = abfd->sections;
378	original_sec && nsecs;
379	original_sec = original_sec->next, nsecs--)
380	{
242eee7a	381	boolean first = true;
885ae6b9 SC	382	int count = 0;
	383	int lines = 0;
	384	int relocs = 0;
	385	struct bfd_link_order **pp;
	386	bfd_vma vma = original_sec->vma;
	387	bfd_vma shift_offset = 0;
	388	asection *cursor = original_sec;
242eee7a	389
885ae6b9 SC	390	/* count up the relocations and line entries to see if
	391	anything would be too big to fit */
	392	for (pp = &(cursor->link_order_head); pp; pp = &((pp)->next))
	393	{
	394	struct bfd_link_order p = pp;
	395	int thislines = 0;
	396	int thisrelocs = 0;
	397	if (p->type == bfd_indirect_link_order)
	398	{
	399	asection *sec;
	400
	401	sec = p->u.indirect.section;
	402
	403	if (info->strip == strip_none
	404	\|\| info->strip == strip_some)
	405	thislines = sec->lineno_count;
	406
	407	if (info->relocateable)
	408	thisrelocs = sec->reloc_count;
	409
	410	}
	411	else if (info->relocateable
	412	&& (p->type == bfd_section_reloc_link_order
	413	\|\| p->type == bfd_symbol_reloc_link_order))
	414	thisrelocs++;
	415
242eee7a ILT	416	if (! first
	417	&& (thisrelocs + relocs > config.split_by_reloc
	418	\|\| thislines + lines > config.split_by_reloc
	419	\|\| config.split_by_file))
885ae6b9 SC	420	{
	421	/* create a new section and put this link order and the
	422	following link orders into it */
	423	struct bfd_link_order *l = p;
	424	asection *n = clone_section (abfd, cursor, &count);
	425	pp = NULL; / Snip off link orders from old section */
	426	n->link_order_head = l; /* attach to new section */
	427	pp = &n->link_order_head;
	428
	429	/* change the size of the original section and
	430	update the vma of the new one */
	431
	432	dump ("before snip", cursor, n);
	433
	434	n->_raw_size = cursor->_raw_size - l->offset;
	435	cursor->_raw_size = l->offset;
	436
	437	vma += cursor->_raw_size;
	438	n->lma = n->vma = vma;
	439
	440	shift_offset = l->offset;
	441
	442	/* run down the chain and change the output section to
	443	the right one, update the offsets too */
	444
	445	while (l)
	446	{
	447	l->offset -= shift_offset;
	448	if (l->type == bfd_indirect_link_order)
	449	{
	450	l->u.indirect.section->output_section = n;
	451	l->u.indirect.section->output_offset = l->offset;
	452	}
	453	l = l->next;
	454	}
	455	dump ("after snip", cursor, n);
	456	cursor = n;
	457	relocs = thisrelocs;
	458	lines = thislines;
	459	}
	460	else
	461	{
	462	relocs += thisrelocs;
	463	lines += thislines;
	464	}
242eee7a ILT	465
242eee7a ILT	466	first = false;
885ae6b9 SC	467	}
	468	}
	469	sanity_check (abfd);
	470	}
	471	/**********************************************************************/
4a6afc88 ILT	472	void
4a6afc88 ILT	473	ldwrite ()
2fa0b342	474	{
242eee7a ILT	475	/* Reset error indicator, which can typically something like invalid
	476	format from openning up the .o files */
	477	bfd_set_error (bfd_error_no_error);
4a6afc88	478	lang_for_each_statement (build_link_order);
2fa0b342	479
885ae6b9 SC	480	if (config.split_by_reloc \|\| config.split_by_file)
	481	split_sections (output_bfd, &link_info);
	482	if (!bfd_final_link (output_bfd, &link_info))
242eee7a ILT	483	{
	484	/* If there was an error recorded, print it out. Otherwise assume
	485	an appropriate error message like unknown symbol was printed
	486	out. */
	487
	488	if (bfd_get_error () != bfd_error_no_error)
	489	einfo ("%F%P: final link failed: %E\n", output_bfd);
	490	else
	491	xexit(1);
	492	}
2fa0b342	493
4a6afc88	494	if (config.map_file)
fcf276c4	495	{
4a6afc88 ILT	496	print_symbol_table ();
4a6afc88 ILT	497	lang_map ();
fcf276c4	498	}
2fa0b342 DHW	499	}
2fa0b342 DHW	500
4a6afc88	501	/* Print the symbol table. */
2fa0b342	502
fcf276c4	503	static void
4a6afc88	504	print_symbol_table ()
2fa0b342	505	{
efa6c497	506	fprintf (config.map_file, "\nFILES\n\n");
4a6afc88 ILT	507	lang_for_each_file (print_file_stuff);
	508
	509	fprintf (config.map_file, "GLOBAL SYMBOLS\n\n");
	510	fprintf (config.map_file, "offset section offset symbol\n");
	511	bfd_link_hash_traverse (link_info.hash, print_symbol, (PTR) NULL);
2fa0b342 DHW	512	}
2fa0b342 DHW	513
4a6afc88 ILT	514	/* Print information about a file. */
	515
	516	static void
	517	print_file_stuff (f)
885ae6b9	518	lang_input_statement_type *f;
4a6afc88 ILT	519	{
	520	fprintf (config.map_file, " %s\n", f->filename);
	521	if (f->just_syms_flag)
	522	{
	523	fprintf (config.map_file, " symbols only\n");
	524	}
	525	else
	526	{
	527	asection *s;
	528	if (true)
	529	{
	530	for (s = f->the_bfd->sections;
	531	s != (asection *) NULL;
	532	s = s->next)
	533	{
242eee7a ILT	534	#ifdef WINDOWS_NT
	535	/* Don't include any information that goes into the '.junk'
	536	section. This includes the code view .debug$ data and
	537	stuff from .drectve sections */
	538	if (strcmp (s->name, ".drectve") == 0 \|\|
	539	strncmp (s->name, ".debug$", 7) == 0)
	540	continue;
	541	#endif
4a6afc88 ILT	542	print_address (s->output_offset);
	543	if (s->reloc_done)
	544	{
	545	fprintf (config.map_file, " %08x 2**%2ud %s\n",
	546	(unsigned) bfd_get_section_size_after_reloc (s),
	547	s->alignment_power, s->name);
	548	}
	549
	550	else
	551	{
	552	fprintf (config.map_file, " %08x 2**%2ud %s\n",
	553	(unsigned) bfd_get_section_size_before_reloc (s),
	554	s->alignment_power, s->name);
	555	}
	556	}
	557	}
	558	else
	559	{
	560	for (s = f->the_bfd->sections;
	561	s != (asection *) NULL;
	562	s = s->next)
	563	{
	564	fprintf (config.map_file, "%s ", s->name);
	565	print_address (s->output_offset);
	566	fprintf (config.map_file, "(%x)",
	567	(unsigned) bfd_get_section_size_after_reloc (s));
	568	}
	569	fprintf (config.map_file, "hex \n");
	570	}
	571	}
	572	print_nl ();
	573	}
	574
	575	/* Print a symbol. */
	576
4fdbafb2	577	/ARGSUSED/
4a6afc88 ILT	578	static boolean
	579	print_symbol (p, ignore)
	580	struct bfd_link_hash_entry *p;
	581	PTR ignore;
2fa0b342	582	{
4a6afc88 ILT	583	while (p->type == bfd_link_hash_indirect
	584	\|\| p->type == bfd_link_hash_warning)
	585	p = p->u.i.link;
	586
885ae6b9	587	switch (p->type)
4a6afc88 ILT	588	{
	589	case bfd_link_hash_new:
	590	abort ();
fcf276c4	591
4a6afc88 ILT	592	case bfd_link_hash_undefined:
	593	fprintf (config.map_file, "undefined ");
	594	fprintf (config.map_file, "%s ", p->root.string);
885ae6b9	595	print_nl ();
4a6afc88	596	break;
fcf276c4	597
242eee7a	598	case bfd_link_hash_undefweak:
4a6afc88 ILT	599	fprintf (config.map_file, "weak ");
4a6afc88 ILT	600	fprintf (config.map_file, "%s ", p->root.string);
885ae6b9	601	print_nl ();
4a6afc88	602	break;
fcf276c4	603
885ae6b9	604	case bfd_link_hash_defined:
242eee7a	605	case bfd_link_hash_defweak:
4a6afc88 ILT	606	{
4a6afc88 ILT	607	asection *defsec = p->u.def.section;
fcf276c4	608
4a6afc88 ILT	609	print_address (p->u.def.value);
	610	if (defsec)
	611	{
	612	fprintf (config.map_file, " %-10s",
	613	bfd_section_name (output_bfd, defsec));
	614	print_space ();
	615	print_address (p->u.def.value + defsec->vma);
	616	}
	617	else
	618	{
	619	fprintf (config.map_file, " .......");
	620	}
242eee7a ILT	621	fprintf (config.map_file, " %s", p->root.string);
	622	if (p->type == bfd_link_hash_defweak)
	623	fprintf (config.map_file, " [weak]");
4a6afc88	624	}
885ae6b9	625	print_nl ();
4a6afc88	626	break;
fcf276c4	627
4a6afc88 ILT	628	case bfd_link_hash_common:
	629	fprintf (config.map_file, "common ");
	630	print_address (p->u.c.size);
	631	fprintf (config.map_file, " %s ", p->root.string);
	632	print_nl ();
	633	break;
2e2bf962	634
4a6afc88 ILT	635	default:
	636	abort ();
	637	}
2e2bf962	638
4a6afc88	639	return true;
2fa0b342	640	}