[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
#   Free Software Foundation, Inc.
#
# 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.
#

# This file is sourced from elf32.em, and defines extra hppa-elf
# specific routines.
#
cat >>e${EMULATION_NAME}.c <<EOF

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

static void hppaelf_after_parse PARAMS((void));
static void hppaelf_create_output_section_statements PARAMS ((void));
static asection *hppaelf_add_stub_section
  PARAMS ((const char *, asection *));
static void hppaelf_layout_sections_again PARAMS ((void));
static void gld${EMULATION_NAME}_finish PARAMS ((void));


/* 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 ()
{
  if (link_info.relocateable)
    lang_add_unique (".text");
#if 0 /* enable this once we split millicode stuff from libgcc */
  else
    lang_add_input_file ("milli",
			 lang_input_file_is_l_enum,
			 NULL);
#endif
}

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

  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 boolean hook_in_stub
  PARAMS ((struct hook_stub_info *, lang_statement_union_type **));

static boolean
hook_in_stub (info, lp)
     struct hook_stub_info *info;
     lang_statement_union_type **lp;
{
  lang_statement_union_type *l;
  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 (stub_sec_name, input_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;

  stub_sec = bfd_make_section_anyway (stub_file->the_bfd, stub_sec_name);
  if (stub_sec == NULL)
    goto err_ret;

  flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
	   | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
  if (!bfd_set_section_flags (stub_file->the_bfd, stub_sec, flags))
    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, stub_file);

  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 ()
{
  /* 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.  */
  need_laying_out = 0;

  lang_reset_memory_regions ();

  /* Resize the sections.  */
  lang_size_sections (stat_ptr->head, abs_output_section,
		      &stat_ptr->head, 0, (bfd_vma) 0, NULL);

  /* Redo special stuff.  */
  ldemul_after_allocation ();

  /* Do the assignments again.  */
  lang_do_assignments (stat_ptr->head, abs_output_section,
		       (fill_type *) 0, (bfd_vma) 0);
}


/* Final emulation specific call.  For the PA we use this opportunity
   to build linker stubs.  */

static void
gld${EMULATION_NAME}_finish ()
{
  /* If generating a relocatable output file, then we don't
     have to examine the relocs.  */
  if (link_info.relocateable)
    return;

  /* bfd_elf32_discard_info just plays with debugging sections,
     ie. doesn't affect any code, so we can delay resizing the
     sections.  It's likely we'll resize everything in the process of
     adding stubs.  */
  if (bfd_elf${ELFSIZE}_discard_info (output_bfd, &link_info))
    need_laying_out = 1;

  /* Call into the BFD backend to do the real work.  */
  if (! elf32_hppa_size_stubs (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)
    hppaelf_layout_sections_again ();

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

  /* Now build the linker stubs.  */
  if (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 hppa_for_each_input_file_wrapper
  PARAMS ((lang_input_statement_type *));
static void hppa_lang_for_each_input_file
  PARAMS ((void (*) (lang_input_statement_type *)));

static void (*real_func) PARAMS ((lang_input_statement_type *));

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

static void
hppa_lang_for_each_input_file (func)
     void (*func) PARAMS ((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)
'

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