[deliverable/binutils-gdb.git] / ld / emultempl / hppaelf.em

# This shell script emits a C file. -*- C -*-
#   Copyright 1991, 1993, 1994, 1997, 1999, 2000, 2001, 2002, 2003, 2004,
#   2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
#
# This file is part of the GNU Binutils.
#
# 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
# MA 02110-1301, USA.
#

# This file is sourced from elf32.em, and defines extra hppa-elf
# specific routines.
#
fragment <<EOF

#include "ldctor.h"
#include "elf32-hppa.h"


/* Fake input file for stubs.  */
static lang_input_statement_type *stub_file;

/* Type of import/export stubs to build.  For a single sub-space model,
   we can build smaller import stubs and there is no need for export
   stubs.  */
static int multi_subspace = 0;

/* Whether we need to call hppa_layout_sections_again.  */
static int need_laying_out = 0;

/* Maximum size of a group of input sections that can be handled by
   one stub section.  A value of +/-1 indicates the bfd back-end
   should use a suitable default size.  */
static bfd_signed_vma group_size = 1;

/* Stops the linker merging .text sections on a relocatable link,
   and adds millicode library to the list of input files.  */

static void
hppaelf_after_parse (void)
{
  if (link_info.relocatable)
    lang_add_unique (".text");

  /* Enable this once we split millicode stuff from libgcc:
     lang_add_input_file ("milli",
     			  lang_input_file_is_l_enum,
			  NULL);
  */
}

/* This is called before the input files are opened.  We create a new
   fake input file to hold the stub sections.  */

static void
hppaelf_create_output_section_statements (void)
{
  if (!(bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
	&& elf_object_id (link_info.output_bfd) == HPPA_ELF_TDATA))
    return;

  stub_file = lang_add_input_file ("linker stubs",
				   lang_input_file_is_fake_enum,
				   NULL);
  stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd);
  if (stub_file->the_bfd == NULL
      || ! bfd_set_arch_mach (stub_file->the_bfd,
			      bfd_get_arch (link_info.output_bfd),
			      bfd_get_mach (link_info.output_bfd)))
    {
      einfo ("%X%P: can not create BFD %E\n");
      return;
    }

  stub_file->the_bfd->flags |= BFD_LINKER_CREATED;
  ldlang_add_file (stub_file);
}


struct hook_stub_info
{
  lang_statement_list_type add;
  asection *input_section;
};

/* Traverse the linker tree to find the spot where the stub goes.  */

static bfd_boolean
hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp)
{
  lang_statement_union_type *l;
  bfd_boolean ret;

  for (; (l = *lp) != NULL; lp = &l->header.next)
    {
      switch (l->header.type)
	{
	case lang_constructors_statement_enum:
	  ret = hook_in_stub (info, &constructor_list.head);
	  if (ret)
	    return ret;
	  break;

	case lang_output_section_statement_enum:
	  ret = hook_in_stub (info,
			      &l->output_section_statement.children.head);
	  if (ret)
	    return ret;
	  break;

	case lang_wild_statement_enum:
	  ret = hook_in_stub (info, &l->wild_statement.children.head);
	  if (ret)
	    return ret;
	  break;

	case lang_group_statement_enum:
	  ret = hook_in_stub (info, &l->group_statement.children.head);
	  if (ret)
	    return ret;
	  break;

	case lang_input_section_enum:
	  if (l->input_section.section == info->input_section)
	    {
	      /* We've found our section.  Insert the stub immediately
		 before its associated input section.  */
	      *lp = info->add.head;
	      *(info->add.tail) = l;
	      return TRUE;
	    }
	  break;

	case lang_data_statement_enum:
	case lang_reloc_statement_enum:
	case lang_object_symbols_statement_enum:
	case lang_output_statement_enum:
	case lang_target_statement_enum:
	case lang_input_statement_enum:
	case lang_assignment_statement_enum:
	case lang_padding_statement_enum:
	case lang_address_statement_enum:
	case lang_fill_statement_enum:
	  break;

	default:
	  FAIL ();
	  break;
	}
    }
  return FALSE;
}


/* Call-back for elf32_hppa_size_stubs.  */

/* Create a new stub section, and arrange for it to be linked
   immediately before INPUT_SECTION.  */

static asection *
hppaelf_add_stub_section (const char *stub_sec_name, asection *input_section)
{
  asection *stub_sec;
  flagword flags;
  asection *output_section;
  const char *secname;
  lang_output_section_statement_type *os;
  struct hook_stub_info info;

  flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
	   | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
  stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
						 stub_sec_name, flags);
  if (stub_sec == NULL)
    goto err_ret;

  output_section = input_section->output_section;
  secname = bfd_get_section_name (output_section->owner, output_section);
  os = lang_output_section_find (secname);

  info.input_section = input_section;
  lang_list_init (&info.add);
  lang_add_section (&info.add, stub_sec, os);

  if (info.add.head == NULL)
    goto err_ret;

  if (hook_in_stub (&info, &os->children.head))
    return stub_sec;

 err_ret:
  einfo ("%X%P: can not make stub section: %E\n");
  return NULL;
}


/* Another call-back for elf32_hppa_size_stubs.  */

static void
hppaelf_layout_sections_again (void)
{
  /* If we have changed sizes of the stub sections, then we need
     to recalculate all the section offsets.  This may mean we need to
     add even more stubs.  */
  gld${EMULATION_NAME}_map_segments (TRUE);
  need_laying_out = -1;
}


static void
build_section_lists (lang_statement_union_type *statement)
{
  if (statement->header.type == lang_input_section_enum)
    {
      asection *i = statement->input_section.section;

      if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
	  && (i->flags & SEC_EXCLUDE) == 0
	  && i->output_section != NULL
	  && i->output_section->owner == link_info.output_bfd)
	{
	  elf32_hppa_next_input_section (&link_info, i);
	}
    }
}


/* For the PA we use this opportunity to size and build linker stubs.  */

static void
gld${EMULATION_NAME}_after_allocation (void)
{
  /* bfd_elf_discard_info just plays with data and debugging sections,
     ie. doesn't affect code size, so we can delay resizing the
     sections.  It's likely we'll resize everything in the process of
     adding stubs.  */
  if (bfd_elf_discard_info (link_info.output_bfd, &link_info))
    need_laying_out = 1;

  /* If generating a relocatable output file, then we don't
     have to examine the relocs.  */
  if (stub_file != NULL && !link_info.relocatable)
    {
      int ret = elf32_hppa_setup_section_lists (link_info.output_bfd,
						&link_info);

      if (ret != 0)
	{
	  if (ret < 0)
	    {
	      einfo ("%X%P: can not size stub section: %E\n");
	      return;
	    }

	  lang_for_each_statement (build_section_lists);

	  /* Call into the BFD backend to do the real work.  */
	  if (! elf32_hppa_size_stubs (link_info.output_bfd,
				       stub_file->the_bfd,
				       &link_info,
				       multi_subspace,
				       group_size,
				       &hppaelf_add_stub_section,
				       &hppaelf_layout_sections_again))
	    {
	      einfo ("%X%P: can not size stub section: %E\n");
	      return;
	    }
	}
    }

  if (need_laying_out != -1)
    gld${EMULATION_NAME}_map_segments (need_laying_out);

  if (! link_info.relocatable)
    {
      /* Set the global data pointer.  */
      if (! elf32_hppa_set_gp (link_info.output_bfd, &link_info))
	{
	  einfo ("%X%P: can not set gp\n");
	  return;
	}

      /* Now build the linker stubs.  */
      if (stub_file != NULL && stub_file->the_bfd->sections != NULL)
	{
	  if (! elf32_hppa_build_stubs (&link_info))
	    einfo ("%X%P: can not build stubs: %E\n");
	}
    }
}


/* Avoid processing the fake stub_file in vercheck, stat_needed and
   check_needed routines.  */

static void (*real_func) (lang_input_statement_type *);

static void hppa_for_each_input_file_wrapper (lang_input_statement_type *l)
{
  if (l != stub_file)
    (*real_func) (l);
}

static void
hppa_lang_for_each_input_file (void (*func) (lang_input_statement_type *))
{
  real_func = func;
  lang_for_each_input_file (&hppa_for_each_input_file_wrapper);
}

#define lang_for_each_input_file hppa_lang_for_each_input_file

EOF

# Define some shell vars to insert bits of code into the standard elf
# parse_args and list_options functions.
#
PARSE_AND_LIST_PROLOGUE='
#define OPTION_MULTI_SUBSPACE		301
#define OPTION_STUBGROUP_SIZE		(OPTION_MULTI_SUBSPACE + 1)
'

PARSE_AND_LIST_LONGOPTS='
  { "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
  { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
'

PARSE_AND_LIST_OPTIONS='
  fprintf (file, _("\
  --multi-subspace            Generate import and export stubs to support\n\
                                multiple sub-space shared libraries\n"
		   ));
  fprintf (file, _("\
  --stub-group-size=N         Maximum size of a group of input sections that\n\
                                can be handled by one stub section.  A negative\n\
                                value locates all stubs before their branches\n\
                                (with a group size of -N), while a positive\n\
                                value allows two groups of input sections, one\n\
                                before, and one after each stub section.\n\
                                Values of +/-1 indicate the linker should\n\
                                choose suitable defaults.\n"
		   ));
'

PARSE_AND_LIST_ARGS_CASES='
    case OPTION_MULTI_SUBSPACE:
      multi_subspace = 1;
      break;

    case OPTION_STUBGROUP_SIZE:
      {
	const char *end;
        group_size = bfd_scan_vma (optarg, &end, 0);
        if (*end)
	  einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
      }
      break;
'

# Put these extra hppaelf routines in ld_${EMULATION_NAME}_emulation
#
LDEMUL_AFTER_PARSE=hppaelf_after_parse
LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=hppaelf_create_output_section_statements
Commit	Line	Data
	1	# This shell script emits a C file. -- C --
	2	# Copyright 1991, 1993, 1994, 1997, 1999, 2000, 2001, 2002, 2003, 2004,
	3	# 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
	4	#
	5	# This file is part of the GNU Binutils.
	6	#
	7	# This program is free software; you can redistribute it and/or modify
	8	# it under the terms of the GNU General Public License as published by
	9	# the Free Software Foundation; either version 3 of the License, or
	10	# (at your option) any later version.
	11	#
	12	# This program is distributed in the hope that it will be useful,
	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
	18	# along with this program; if not, write to the Free Software
	19	# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	20	# MA 02110-1301, USA.
	21	#
	22
	23	# This file is sourced from elf32.em, and defines extra hppa-elf
	24	# specific routines.
	25	#
	26	fragment <<EOF
	27
	28	#include "ldctor.h"
	29	#include "elf32-hppa.h"
	30
	31
	32	/* Fake input file for stubs. */
	33	static lang_input_statement_type *stub_file;
	34
	35	/* Type of import/export stubs to build. For a single sub-space model,
	36	we can build smaller import stubs and there is no need for export
	37	stubs. */
	38	static int multi_subspace = 0;
	39
	40	/* Whether we need to call hppa_layout_sections_again. */
	41	static int need_laying_out = 0;
	42
	43	/* Maximum size of a group of input sections that can be handled by
	44	one stub section. A value of +/-1 indicates the bfd back-end
	45	should use a suitable default size. */
	46	static bfd_signed_vma group_size = 1;
	47
	48	/* Stops the linker merging .text sections on a relocatable link,
	49	and adds millicode library to the list of input files. */
	50
	51	static void
	52	hppaelf_after_parse (void)
	53	{
	54	if (link_info.relocatable)
	55	lang_add_unique (".text");
	56
	57	/* Enable this once we split millicode stuff from libgcc:
	58	lang_add_input_file ("milli",
	59	lang_input_file_is_l_enum,
	60	NULL);
	61	*/
	62	}
	63
	64	/* This is called before the input files are opened. We create a new
	65	fake input file to hold the stub sections. */
	66
	67	static void
	68	hppaelf_create_output_section_statements (void)
	69	{
	70	if (!(bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
	71	&& elf_object_id (link_info.output_bfd) == HPPA_ELF_TDATA))
	72	return;
	73
	74	stub_file = lang_add_input_file ("linker stubs",
	75	lang_input_file_is_fake_enum,
	76	NULL);
	77	stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd);
	78	if (stub_file->the_bfd == NULL
	79	\|\| ! bfd_set_arch_mach (stub_file->the_bfd,
	80	bfd_get_arch (link_info.output_bfd),
	81	bfd_get_mach (link_info.output_bfd)))
	82	{
	83	einfo ("%X%P: can not create BFD %E\n");
	84	return;
	85	}
	86
	87	stub_file->the_bfd->flags \|= BFD_LINKER_CREATED;
	88	ldlang_add_file (stub_file);
	89	}
	90
	91
	92	struct hook_stub_info
	93	{
	94	lang_statement_list_type add;
	95	asection *input_section;
	96	};
	97
	98	/* Traverse the linker tree to find the spot where the stub goes. */
	99
	100	static bfd_boolean
	101	hook_in_stub (struct hook_stub_info info, lang_statement_union_type *lp)
	102	{
	103	lang_statement_union_type *l;
	104	bfd_boolean ret;
	105
	106	for (; (l = *lp) != NULL; lp = &l->header.next)
	107	{
	108	switch (l->header.type)
	109	{
	110	case lang_constructors_statement_enum:
	111	ret = hook_in_stub (info, &constructor_list.head);
	112	if (ret)
	113	return ret;
	114	break;
	115
	116	case lang_output_section_statement_enum:
	117	ret = hook_in_stub (info,
	118	&l->output_section_statement.children.head);
	119	if (ret)
	120	return ret;
	121	break;
	122
	123	case lang_wild_statement_enum:
	124	ret = hook_in_stub (info, &l->wild_statement.children.head);
	125	if (ret)
	126	return ret;
	127	break;
	128
	129	case lang_group_statement_enum:
	130	ret = hook_in_stub (info, &l->group_statement.children.head);
	131	if (ret)
	132	return ret;
	133	break;
	134
	135	case lang_input_section_enum:
	136	if (l->input_section.section == info->input_section)
	137	{
	138	/* We've found our section. Insert the stub immediately
	139	before its associated input section. */
	140	*lp = info->add.head;
	141	*(info->add.tail) = l;
	142	return TRUE;
	143	}
	144	break;
	145
	146	case lang_data_statement_enum:
	147	case lang_reloc_statement_enum:
	148	case lang_object_symbols_statement_enum:
	149	case lang_output_statement_enum:
	150	case lang_target_statement_enum:
	151	case lang_input_statement_enum:
	152	case lang_assignment_statement_enum:
	153	case lang_padding_statement_enum:
	154	case lang_address_statement_enum:
	155	case lang_fill_statement_enum:
	156	break;
	157
	158	default:
	159	FAIL ();
	160	break;
	161	}
	162	}
	163	return FALSE;
	164	}
	165
	166
	167	/* Call-back for elf32_hppa_size_stubs. */
	168
	169	/* Create a new stub section, and arrange for it to be linked
	170	immediately before INPUT_SECTION. */
	171
	172	static asection *
	173	hppaelf_add_stub_section (const char stub_sec_name, asection input_section)
	174	{
	175	asection *stub_sec;
	176	flagword flags;
	177	asection *output_section;
	178	const char *secname;
	179	lang_output_section_statement_type *os;
	180	struct hook_stub_info info;
	181
	182	flags = (SEC_ALLOC \| SEC_LOAD \| SEC_READONLY \| SEC_CODE
	183	\| SEC_HAS_CONTENTS \| SEC_RELOC \| SEC_IN_MEMORY \| SEC_KEEP);
	184	stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
	185	stub_sec_name, flags);
	186	if (stub_sec == NULL)
	187	goto err_ret;
	188
	189	output_section = input_section->output_section;
	190	secname = bfd_get_section_name (output_section->owner, output_section);
	191	os = lang_output_section_find (secname);
	192
	193	info.input_section = input_section;
	194	lang_list_init (&info.add);
	195	lang_add_section (&info.add, stub_sec, os);
	196
	197	if (info.add.head == NULL)
	198	goto err_ret;
	199
	200	if (hook_in_stub (&info, &os->children.head))
	201	return stub_sec;
	202
	203	err_ret:
	204	einfo ("%X%P: can not make stub section: %E\n");
	205	return NULL;
	206	}
	207
	208
	209	/* Another call-back for elf32_hppa_size_stubs. */
	210
	211	static void
	212	hppaelf_layout_sections_again (void)
	213	{
	214	/* If we have changed sizes of the stub sections, then we need
	215	to recalculate all the section offsets. This may mean we need to
	216	add even more stubs. */
	217	gld${EMULATION_NAME}_map_segments (TRUE);
	218	need_laying_out = -1;
	219	}
	220
	221
	222	static void
	223	build_section_lists (lang_statement_union_type *statement)
	224	{
	225	if (statement->header.type == lang_input_section_enum)
	226	{
	227	asection *i = statement->input_section.section;
	228
	229	if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
	230	&& (i->flags & SEC_EXCLUDE) == 0
	231	&& i->output_section != NULL
	232	&& i->output_section->owner == link_info.output_bfd)
	233	{
	234	elf32_hppa_next_input_section (&link_info, i);
	235	}
	236	}
	237	}
	238
	239
	240	/* For the PA we use this opportunity to size and build linker stubs. */
	241
	242	static void
	243	gld${EMULATION_NAME}_after_allocation (void)
	244	{
	245	/* bfd_elf_discard_info just plays with data and debugging sections,
	246	ie. doesn't affect code size, so we can delay resizing the
	247	sections. It's likely we'll resize everything in the process of
	248	adding stubs. */
	249	if (bfd_elf_discard_info (link_info.output_bfd, &link_info))
	250	need_laying_out = 1;
	251
	252	/* If generating a relocatable output file, then we don't
	253	have to examine the relocs. */
	254	if (stub_file != NULL && !link_info.relocatable)
	255	{
	256	int ret = elf32_hppa_setup_section_lists (link_info.output_bfd,
	257	&link_info);
	258
	259	if (ret != 0)
	260	{
	261	if (ret < 0)
	262	{
	263	einfo ("%X%P: can not size stub section: %E\n");
	264	return;
	265	}
	266
	267	lang_for_each_statement (build_section_lists);
	268
	269	/* Call into the BFD backend to do the real work. */
	270	if (! elf32_hppa_size_stubs (link_info.output_bfd,
	271	stub_file->the_bfd,
	272	&link_info,
	273	multi_subspace,
	274	group_size,
	275	&hppaelf_add_stub_section,
	276	&hppaelf_layout_sections_again))
	277	{
	278	einfo ("%X%P: can not size stub section: %E\n");
	279	return;
	280	}
	281	}
	282	}
	283
	284	if (need_laying_out != -1)
	285	gld${EMULATION_NAME}_map_segments (need_laying_out);
	286
	287	if (! link_info.relocatable)
	288	{
	289	/* Set the global data pointer. */
	290	if (! elf32_hppa_set_gp (link_info.output_bfd, &link_info))
	291	{
	292	einfo ("%X%P: can not set gp\n");
	293	return;
	294	}
	295
	296	/* Now build the linker stubs. */
	297	if (stub_file != NULL && stub_file->the_bfd->sections != NULL)
	298	{
	299	if (! elf32_hppa_build_stubs (&link_info))
	300	einfo ("%X%P: can not build stubs: %E\n");
	301	}
	302	}
	303	}
	304
	305
	306	/* Avoid processing the fake stub_file in vercheck, stat_needed and
	307	check_needed routines. */
	308
	309	static void (real_func) (lang_input_statement_type );
	310
	311	static void hppa_for_each_input_file_wrapper (lang_input_statement_type *l)
	312	{
	313	if (l != stub_file)
	314	(*real_func) (l);
	315	}
	316
	317	static void
	318	hppa_lang_for_each_input_file (void (func) (lang_input_statement_type ))
	319	{
	320	real_func = func;
	321	lang_for_each_input_file (&hppa_for_each_input_file_wrapper);
	322	}
	323
	324	#define lang_for_each_input_file hppa_lang_for_each_input_file
	325
	326	EOF
	327
	328	# Define some shell vars to insert bits of code into the standard elf
	329	# parse_args and list_options functions.
	330	#
	331	PARSE_AND_LIST_PROLOGUE='
	332	#define OPTION_MULTI_SUBSPACE 301
	333	#define OPTION_STUBGROUP_SIZE (OPTION_MULTI_SUBSPACE + 1)
	334	'
	335
	336	PARSE_AND_LIST_LONGOPTS='
	337	{ "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
	338	{ "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
	339	'
	340
	341	PARSE_AND_LIST_OPTIONS='
	342	fprintf (file, _("\
	343	--multi-subspace Generate import and export stubs to support\n\
	344	multiple sub-space shared libraries\n"
	345	));
	346	fprintf (file, _("\
	347	--stub-group-size=N Maximum size of a group of input sections that\n\
	348	can be handled by one stub section. A negative\n\
	349	value locates all stubs before their branches\n\
	350	(with a group size of -N), while a positive\n\
	351	value allows two groups of input sections, one\n\
	352	before, and one after each stub section.\n\
	353	Values of +/-1 indicate the linker should\n\
	354	choose suitable defaults.\n"
	355	));
	356	'
	357
	358	PARSE_AND_LIST_ARGS_CASES='
	359	case OPTION_MULTI_SUBSPACE:
	360	multi_subspace = 1;
	361	break;
	362
	363	case OPTION_STUBGROUP_SIZE:
	364	{
	365	const char *end;
	366	group_size = bfd_scan_vma (optarg, &end, 0);
	367	if (*end)
	368	einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
	369	}
	370	break;
	371	'
	372
	373	# Put these extra hppaelf routines in ld_${EMULATION_NAME}_emulation
	374	#
	375	LDEMUL_AFTER_PARSE=hppaelf_after_parse
	376	LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
	377	LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=hppaelf_create_output_section_statements