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

# This shell script emits a C file. -*- C -*-
#   Copyright 1991, 1993, 1994, 1997, 1999, 2000, 2001
#   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;

  /* 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
252b5132	1	# This shell script emits a C file. -- C --
a2b64bed	2	# Copyright 1991, 1993, 1994, 1997, 1999, 2000, 2001
41392f03 AM	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
252b5132	27	#include "ldctor.h"
4900fc06	28	#include "elf32-hppa.h"
252b5132	29
ffd6e9de	30	static void hppaelf_after_parse PARAMS((void));
4900fc06	31	static void hppaelf_create_output_section_statements PARAMS ((void));
41392f03 AM	32	static asection *hppaelf_add_stub_section
41392f03 AM	33	PARAMS ((const char , asection ));
c56feb2b AM	34	static void hppaelf_layout_sections_again PARAMS ((void));
c56feb2b AM	35	static void gld${EMULATION_NAME}_finish PARAMS ((void));
252b5132 RH	36
252b5132 RH	37
4900fc06 AM	38	/* Fake input file for stubs. */
4900fc06 AM	39	static lang_input_statement_type *stub_file;
252b5132	40
3231d22e AM	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;
252b5132	45
c56feb2b AM	46	/* Whether we need to call hppa_layout_sections_again. */
	47	static int need_laying_out = 0;
	48
47d89dba AM	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;
252b5132	53
ffd6e9de AM	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
252b5132	70	/* This is called before the input files are opened. We create a new
4900fc06	71	fake input file to hold the stub sections. */
252b5132 RH	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
252b5132 RH	89	ldlang_add_file (stub_file);
	90	}
	91
4900fc06 AM	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
41392f03 AM	101	static boolean hook_in_stub
	102	PARAMS ((struct hook_stub_info , lang_statement_union_type *));
	103
4900fc06 AM	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
bba1a0c0	112	for (; (l = *lp) != NULL; lp = &l->header.next)
4900fc06 AM	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
41392f03	172
4900fc06 AM	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 *
25f72752 AM	179	hppaelf_add_stub_section (stub_sec_name, input_section)
25f72752 AM	180	const char *stub_sec_name;
4900fc06 AM	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
25f72752	190	stub_sec = bfd_make_section_anyway (stub_file->the_bfd, stub_sec_name);
4900fc06 AM	191	if (stub_sec == NULL)
	192	goto err_ret;
	193
	194	flags = (SEC_ALLOC \| SEC_LOAD \| SEC_READONLY \| SEC_CODE
3231d22e	195	\| SEC_HAS_CONTENTS \| SEC_RELOC \| SEC_IN_MEMORY \| SEC_KEEP);
4900fc06 AM	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);
39dcfe18	205	lang_add_section (&info.add, stub_sec, os, stub_file);
4900fc06 AM	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
41392f03	218
4900fc06 AM	219	/* Another call-back for elf32_hppa_size_stubs. */
	220
	221	static void
c56feb2b	222	hppaelf_layout_sections_again ()
4900fc06 AM	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. */
c56feb2b	227	need_laying_out = 0;
4900fc06	228
4900fc06 AM	229	/* Resize the sections. */
4900fc06 AM	230	lang_size_sections (stat_ptr->head, abs_output_section,
ca0b5847	231	&stat_ptr->head, 0, (bfd_vma) 0, NULL);
4900fc06 AM	232
	233	/* Redo special stuff. */
	234	ldemul_after_allocation ();
	235
	236	/* Do the assignments again. */
	237	lang_do_assignments (stat_ptr->head, abs_output_section,
	238	(fill_type) 0, (bfd_vma) 0);
	239	}
	240
	241
252b5132 RH	242	/* Final emulation specific call. For the PA we use this opportunity
	243	to build linker stubs. */
	244
	245	static void
c56feb2b	246	gld${EMULATION_NAME}_finish ()
252b5132	247	{
ffd6e9de	248	/* If generating a relocatable output file, then we don't
4900fc06 AM	249	have to examine the relocs. */
	250	if (link_info.relocateable)
	251	return;
	252
c56feb2b AM	253	/* bfd_elf32_discard_info just plays with debugging sections,
	254	ie. doesn't affect any code, so we can delay resizing the
	255	sections. It's likely we'll resize everything in the process of
	256	adding stubs. */
65765700	257	if (bfd_elf${ELFSIZE}_discard_info (output_bfd, &link_info))
c56feb2b AM	258	need_laying_out = 1;
c56feb2b AM	259
252b5132	260	/* Call into the BFD backend to do the real work. */
25f72752 AM	261	if (! elf32_hppa_size_stubs (output_bfd,
25f72752 AM	262	stub_file->the_bfd,
41392f03	263	&link_info,
25f72752	264	multi_subspace,
47d89dba	265	group_size,
41392f03	266	&hppaelf_add_stub_section,
c56feb2b	267	&hppaelf_layout_sections_again))
252b5132 RH	268	{
	269	einfo ("%X%P: can not size stub section: %E\n");
	270	return;
	271	}
4900fc06	272
c56feb2b AM	273	if (need_laying_out)
	274	hppaelf_layout_sections_again ();
	275
3231d22e AM	276	/* Set the global data pointer. */
	277	if (! elf32_hppa_set_gp (output_bfd, &link_info))
	278	{
	279	einfo ("%X%P: can not set gp\n");
	280	return;
	281	}
	282
4900fc06 AM	283	/* Now build the linker stubs. */
4900fc06 AM	284	if (stub_file->the_bfd->sections != NULL)
252b5132	285	{
3231d22e	286	if (! elf32_hppa_build_stubs (&link_info))
4900fc06 AM	287	einfo ("%X%P: can not build stubs: %E\n");
	288	}
	289	}
	290
3231d22e AM	291
	292	/* Avoid processing the fake stub_file in vercheck, stat_needed and
	293	check_needed routines. */
	294
	295	static void hppa_for_each_input_file_wrapper
	296	PARAMS ((lang_input_statement_type *));
	297	static void hppa_lang_for_each_input_file
	298	PARAMS ((void () (lang_input_statement_type )));
	299
	300	static void (real_func) PARAMS ((lang_input_statement_type ));
	301
	302	static void hppa_for_each_input_file_wrapper (l)
	303	lang_input_statement_type *l;
	304	{
	305	if (l != stub_file)
	306	(*real_func) (l);
	307	}
	308
	309	static void
	310	hppa_lang_for_each_input_file (func)
	311	void (func) PARAMS ((lang_input_statement_type ));
	312	{
	313	real_func = func;
	314	lang_for_each_input_file (&hppa_for_each_input_file_wrapper);
	315	}
	316
	317	#define lang_for_each_input_file hppa_lang_for_each_input_file
	318
252b5132 RH	319	EOF
252b5132 RH	320
3231d22e AM	321	# Define some shell vars to insert bits of code into the standard elf
	322	# parse_args and list_options functions.
	323	#
	324	PARSE_AND_LIST_PROLOGUE='
	325	#define OPTION_MULTI_SUBSPACE 301
47d89dba	326	#define OPTION_STUBGROUP_SIZE (OPTION_MULTI_SUBSPACE + 1)
3231d22e AM	327	'
3231d22e AM	328
47d89dba AM	329	# The options are repeated below so that no abbreviations are allowed.
47d89dba AM	330	# Otherwise -s matches stub-group-size
3231d22e	331	PARSE_AND_LIST_LONGOPTS='
47d89dba AM	332	{ "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
	333	{ "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
	334	{ "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
	335	{ "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
3231d22e AM	336	'
	337
	338	PARSE_AND_LIST_OPTIONS='
	339	fprintf (file, _("\
c56feb2b AM	340	--multi-subspace Generate import and export stubs to support\n\
c56feb2b AM	341	multiple sub-space shared libraries\n"
47d89dba AM	342	));
47d89dba AM	343	fprintf (file, _("\
c56feb2b AM	344	--stub-group-size=N Maximum size of a group of input sections that can be\n\
	345	handled by one stub section. A negative value\n\
	346	locates all stubs before their branches (with a\n\
	347	group size of -N), while a positive value allows\n\
	348	two groups of input sections, one before, and one\n\
	349	after each stub section. Values of +/-1 indicate\n\
	350	the linker should choose suitable defaults.\n"
3231d22e AM	351	));
	352	'
	353
	354	PARSE_AND_LIST_ARGS_CASES='
	355	case OPTION_MULTI_SUBSPACE:
	356	multi_subspace = 1;
	357	break;
47d89dba AM	358
	359	case OPTION_STUBGROUP_SIZE:
	360	{
	361	const char *end;
	362	group_size = bfd_scan_vma (optarg, &end, 0);
	363	if (*end)
	364	einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
	365	}
	366	break;
3231d22e AM	367	'
	368
	369	# Put these extra hppaelf routines in ld_${EMULATION_NAME}_emulation
41392f03	370	#
ffd6e9de	371	LDEMUL_AFTER_PARSE=hppaelf_after_parse
c56feb2b	372	LDEMUL_FINISH=gld${EMULATION_NAME}_finish
41392f03	373	LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=hppaelf_create_output_section_statements