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

/* ldwrite.c -- write out the linked file
   Copyright (C) 1993 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., 675 Mass Ave, Cambridge, MA 02139, 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));

/* 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:
      /* FIXME: This should probably build a link_order, but instead
	 it just does the output directly.  */
      {
	bfd_vma value = statement->data_statement.value;
	bfd_byte play_area[QUAD_SIZE];
	unsigned int size = 0;
	asection *output_section = statement->data_statement.output_section;

	ASSERT (output_section->owner == output_bfd);
	switch (statement->data_statement.type)
	  {
	  case QUAD:
	    bfd_put_64 (output_bfd, value, play_area);
	    size = QUAD_SIZE;
	    break;
	  case LONG:
	    bfd_put_32 (output_bfd, value, play_area);
	    size = LONG_SIZE;
	    break;
	  case SHORT:
	    bfd_put_16 (output_bfd, value, play_area);
	    size = SHORT_SIZE;
	    break;
	  case BYTE:
	    bfd_put_8 (output_bfd, value, play_area);
	    size = BYTE_SIZE;
	    break;
	  default:
	    abort ();
	  }

	if (! bfd_set_section_contents (output_bfd, output_section,
					play_area,
					statement->data_statement.output_vma,
					size))
	  einfo ("%P%X: writing data failed: %E\n");
      }
      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");

	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->section != (asection *) NULL)
	  {
	    ASSERT (rs->name == (const char *) 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
	  {
	    ASSERT (rs->name != (const char *) NULL);
	    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.  */

void
ldwrite ()
{
  lang_for_each_statement (build_link_order);

  if (! bfd_final_link (output_bfd, &link_info))
    einfo ("%F%P: final link failed: %E\n", output_bfd);

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

/* Print the symbol table.  */

static void
print_symbol_table ()
{
  fprintf (config.map_file, "**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)
	    {
	      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_weak:
      fprintf (config.map_file, "weak                          ");
      fprintf (config.map_file, "%s ", p->root.string);
      print_nl ();    
      break;

    case bfd_link_hash_defined:	    
      {
	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);
      }
      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 sac@cygnus.com
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 SC	18	along with this program; if not, write to the Free Software
2e2bf962 SC	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 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
	38	/* Build link_order structures for the BFD linker. */
2fa0b342 DHW	39
2fa0b342 DHW	40	static void
4a6afc88 ILT	41	build_link_order (statement)
	42	lang_statement_union_type *statement;
	43	{
	44	switch (statement->header.type)
	45	{
	46	case lang_data_statement_enum:
	47	/* FIXME: This should probably build a link_order, but instead
	48	it just does the output directly. */
	49	{
	50	bfd_vma value = statement->data_statement.value;
4fdbafb2	51	bfd_byte play_area[QUAD_SIZE];
4a6afc88 ILT	52	unsigned int size = 0;
	53	asection *output_section = statement->data_statement.output_section;
	54
	55	ASSERT (output_section->owner == output_bfd);
	56	switch (statement->data_statement.type)
	57	{
4fdbafb2 ILT	58	case QUAD:
	59	bfd_put_64 (output_bfd, value, play_area);
	60	size = QUAD_SIZE;
	61	break;
4a6afc88 ILT	62	case LONG:
	63	bfd_put_32 (output_bfd, value, play_area);
	64	size = LONG_SIZE;
	65	break;
	66	case SHORT:
	67	bfd_put_16 (output_bfd, value, play_area);
	68	size = SHORT_SIZE;
	69	break;
	70	case BYTE:
	71	bfd_put_8 (output_bfd, value, play_area);
	72	size = BYTE_SIZE;
	73	break;
	74	default:
	75	abort ();
	76	}
	77
	78	if (! bfd_set_section_contents (output_bfd, output_section,
	79	play_area,
	80	statement->data_statement.output_vma,
	81	size))
	82	einfo ("%P%X: writing data failed: %E\n");
	83	}
	84	break;
	85
4fdbafb2 ILT	86	case lang_reloc_statement_enum:
	87	{
	88	lang_reloc_statement_type *rs;
	89	asection *output_section;
	90	struct bfd_link_order *link_order;
	91
	92	rs = &statement->reloc_statement;
	93
	94	output_section = rs->output_section;
	95	ASSERT (output_section->owner == output_bfd);
	96
	97	link_order = bfd_new_link_order (output_bfd, output_section);
	98	if (link_order == NULL)
	99	einfo ("%P%F: bfd_new_link_order failed");
	100
	101	link_order->offset = rs->output_vma;
	102	link_order->size = bfd_get_reloc_size (rs->howto);
	103
	104	link_order->u.reloc.p =
	105	((struct bfd_link_order_reloc *)
	106	xmalloc (sizeof (struct bfd_link_order_reloc)));
	107
	108	link_order->u.reloc.p->reloc = rs->reloc;
	109	link_order->u.reloc.p->addend = rs->addend_value;
	110
	111	if (rs->section != (asection *) NULL)
	112	{
	113	ASSERT (rs->name == (const char *) NULL);
	114	link_order->type = bfd_section_reloc_link_order;
	115	if (rs->section->owner == output_bfd)
	116	link_order->u.reloc.p->u.section = rs->section;
	117	else
	118	{
	119	link_order->u.reloc.p->u.section = rs->section->output_section;
	120	link_order->u.reloc.p->addend += rs->section->output_offset;
	121	}
	122	}
	123	else
	124	{
	125	ASSERT (rs->name != (const char *) NULL);
	126	link_order->type = bfd_symbol_reloc_link_order;
	127	link_order->u.reloc.p->u.name = rs->name;
	128	}
	129	}
	130	break;
	131
4a6afc88 ILT	132	case lang_input_section_enum:
	133	/* Create a new link_order in the output section with this
	134	attached */
	135	if (statement->input_section.ifile->just_syms_flag == false)
	136	{
	137	asection *i = statement->input_section.section;
	138	asection *output_section = i->output_section;
	139
	140	ASSERT (output_section->owner == output_bfd);
	141
	142	if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
	143	{
	144	struct bfd_link_order *link_order;
	145
	146	link_order = bfd_new_link_order (output_bfd, output_section);
	147
	148	if (i->flags & SEC_NEVER_LOAD)
	149	{
	150	/* We've got a never load section inside one which
	151	is going to be output, we'll change it into a
	152	fill link_order */
	153	link_order->type = bfd_fill_link_order;
	154	link_order->u.fill.value = 0;
	155	}
	156	else
	157	{
	158	link_order->type = bfd_indirect_link_order;
	159	link_order->u.indirect.section = i;
	160	ASSERT (i->output_section == output_section);
	161	}
4fdbafb2 ILT	162	if (i->_cooked_size)
	163	link_order->size = i->_cooked_size;
	164	else
	165	link_order->size = bfd_get_section_size_before_reloc (i);
4a6afc88 ILT	166	link_order->offset = i->output_offset;
	167	}
	168	}
	169	break;
	170
	171	case lang_padding_statement_enum:
	172	/* Make a new link_order with the right filler */
	173	{
	174	asection *output_section;
	175	struct bfd_link_order *link_order;
	176
	177	output_section = statement->padding_statement.output_section;
	178	ASSERT (statement->padding_statement.output_section->owner
	179	== output_bfd);
	180	if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
	181	{
	182	link_order = bfd_new_link_order (output_bfd, output_section);
	183	link_order->type = bfd_fill_link_order;
	184	link_order->size = statement->padding_statement.size;
	185	link_order->offset = statement->padding_statement.output_offset;
	186	link_order->u.fill.value = statement->padding_statement.fill;
	187	}
	188	}
	189	break;
	190
	191	default:
	192	/* All the other ones fall through */
	193	break;
	194	}
	195	}
	196
	197	/* Call BFD to write out the linked file. */
	198
	199	void
	200	ldwrite ()
2fa0b342	201	{
4a6afc88	202	lang_for_each_statement (build_link_order);
2fa0b342	203
4a6afc88	204	if (! bfd_final_link (output_bfd, &link_info))
4fdbafb2	205	einfo ("%F%P: final link failed: %E\n", output_bfd);
2fa0b342	206
4a6afc88	207	if (config.map_file)
fcf276c4	208	{
4a6afc88 ILT	209	print_symbol_table ();
4a6afc88 ILT	210	lang_map ();
fcf276c4	211	}
2fa0b342 DHW	212	}
2fa0b342 DHW	213
4a6afc88	214	/* Print the symbol table. */
2fa0b342	215
fcf276c4	216	static void
4a6afc88	217	print_symbol_table ()
2fa0b342	218	{
4a6afc88 ILT	219	fprintf (config.map_file, "FILES\n\n");
	220	lang_for_each_file (print_file_stuff);
	221
	222	fprintf (config.map_file, "GLOBAL SYMBOLS\n\n");
	223	fprintf (config.map_file, "offset section offset symbol\n");
	224	bfd_link_hash_traverse (link_info.hash, print_symbol, (PTR) NULL);
2fa0b342 DHW	225	}
2fa0b342 DHW	226
4a6afc88 ILT	227	/* Print information about a file. */
	228
	229	static void
	230	print_file_stuff (f)
	231	lang_input_statement_type * f;
	232	{
	233	fprintf (config.map_file, " %s\n", f->filename);
	234	if (f->just_syms_flag)
	235	{
	236	fprintf (config.map_file, " symbols only\n");
	237	}
	238	else
	239	{
	240	asection *s;
	241	if (true)
	242	{
	243	for (s = f->the_bfd->sections;
	244	s != (asection *) NULL;
	245	s = s->next)
	246	{
	247	print_address (s->output_offset);
	248	if (s->reloc_done)
	249	{
	250	fprintf (config.map_file, " %08x 2**%2ud %s\n",
	251	(unsigned) bfd_get_section_size_after_reloc (s),
	252	s->alignment_power, s->name);
	253	}
	254
	255	else
	256	{
	257	fprintf (config.map_file, " %08x 2**%2ud %s\n",
	258	(unsigned) bfd_get_section_size_before_reloc (s),
	259	s->alignment_power, s->name);
	260	}
	261	}
	262	}
	263	else
	264	{
	265	for (s = f->the_bfd->sections;
	266	s != (asection *) NULL;
	267	s = s->next)
	268	{
	269	fprintf (config.map_file, "%s ", s->name);
	270	print_address (s->output_offset);
	271	fprintf (config.map_file, "(%x)",
	272	(unsigned) bfd_get_section_size_after_reloc (s));
	273	}
	274	fprintf (config.map_file, "hex \n");
	275	}
	276	}
	277	print_nl ();
	278	}
	279
	280	/* Print a symbol. */
	281
4fdbafb2	282	/ARGSUSED/
4a6afc88 ILT	283	static boolean
	284	print_symbol (p, ignore)
	285	struct bfd_link_hash_entry *p;
	286	PTR ignore;
2fa0b342	287	{
4a6afc88 ILT	288	while (p->type == bfd_link_hash_indirect
	289	\|\| p->type == bfd_link_hash_warning)
	290	p = p->u.i.link;
	291
	292	switch (p->type)
	293	{
	294	case bfd_link_hash_new:
	295	abort ();
fcf276c4	296
4a6afc88 ILT	297	case bfd_link_hash_undefined:
	298	fprintf (config.map_file, "undefined ");
	299	fprintf (config.map_file, "%s ", p->root.string);
	300	print_nl ();
	301	break;
fcf276c4	302
4a6afc88 ILT	303	case bfd_link_hash_weak:
	304	fprintf (config.map_file, "weak ");
	305	fprintf (config.map_file, "%s ", p->root.string);
	306	print_nl ();
	307	break;
fcf276c4	308
4a6afc88 ILT	309	case bfd_link_hash_defined:
	310	{
	311	asection *defsec = p->u.def.section;
fcf276c4	312
4a6afc88 ILT	313	print_address (p->u.def.value);
	314	if (defsec)
	315	{
	316	fprintf (config.map_file, " %-10s",
	317	bfd_section_name (output_bfd, defsec));
	318	print_space ();
	319	print_address (p->u.def.value + defsec->vma);
	320	}
	321	else
	322	{
	323	fprintf (config.map_file, " .......");
	324	}
	325	fprintf (config.map_file, " %s ", p->root.string);
	326	}
	327	print_nl ();
	328	break;
fcf276c4	329
4a6afc88 ILT	330	case bfd_link_hash_common:
	331	fprintf (config.map_file, "common ");
	332	print_address (p->u.c.size);
	333	fprintf (config.map_file, " %s ", p->root.string);
	334	print_nl ();
	335	break;
2e2bf962	336
4a6afc88 ILT	337	default:
	338	abort ();
	339	}
2e2bf962	340
4a6afc88	341	return true;
2fa0b342	342	}