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

# This shell script emits a C file. -*- C -*-
#   Copyright (C) 2003-2020 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 elf.em, and defines extra powerpc32-elf
# specific routines.
#
fragment <<EOF

#include "elf32-ppc.h"
#include "ldlex.h"
#include "ldlang.h"

#define is_ppc_elf(bfd) \
  (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
   && elf_object_id (bfd) == PPC32_ELF_DATA)

/* Whether to run tls optimization.  */
static int notlsopt = 0;

/* Whether to convert inline PLT calls to direct.  */
static int no_inline_opt = 0;

/* Choose the correct place for .got.  */
static int old_got = 0;

static struct ppc_elf_params params = { PLT_UNSET, 0, -1,
					0, 0, 0, 0, 0, 0, 0 };

static void
ppc_after_open_output (void)
{
  if (params.emit_stub_syms < 0)
    params.emit_stub_syms = (link_info.emitrelocations
			     || bfd_link_pic (&link_info));
  if (params.pagesize == 0)
    params.pagesize = config.commonpagesize;
  ppc_elf_link_params (&link_info, &params);
}

EOF

# No --secure-plt, --bss-plt, or --sdata-got for vxworks.
if test -z "$VXWORKS_BASE_EM_FILE" ; then
  fragment <<EOF
static void
ppc_after_check_relocs (void)
{
  if (is_ppc_elf (link_info.output_bfd))
    {
      int new_plt;
      int keep_new;
      unsigned int num_plt;
      unsigned int num_got;
      lang_output_section_statement_type *os;
      lang_output_section_statement_type *plt_os[2];
      lang_output_section_statement_type *got_os[2];

      new_plt = ppc_elf_select_plt_layout (link_info.output_bfd, &link_info);
      if (new_plt < 0)
	einfo (_("%X%P: select_plt_layout problem %E\n"));

      num_got = 0;
      num_plt = 0;
      for (os = (void *) lang_os_list.head;
	   os != NULL;
	   os = os->next)
	{
	  if (os->constraint == SPECIAL && strcmp (os->name, ".plt") == 0)
	    {
	      if (num_plt < 2)
		plt_os[num_plt] = os;
	      ++num_plt;
	    }
	  if (os->constraint == SPECIAL && strcmp (os->name, ".got") == 0)
	    {
	      if (num_got < 2)
		got_os[num_got] = os;
	      ++num_got;
	    }
	}

      keep_new = new_plt == 1 ? 0 : -1;
      if (num_plt == 2)
	{
	  plt_os[0]->constraint = keep_new;
	  plt_os[1]->constraint = ~keep_new;
	}
      if (num_got == 2)
	{
	  if (old_got)
	    keep_new = -1;
	  got_os[0]->constraint = keep_new;
	  got_os[1]->constraint = ~keep_new;
	}
    }

  after_check_relocs_default ();
}

EOF
fi
fragment <<EOF
static void
prelim_size_sections (void)
{
  if (expld.phase != lang_mark_phase_enum)
    {
      expld.phase = lang_mark_phase_enum;
      expld.dataseg.phase = exp_seg_none;
      one_lang_size_sections_pass (NULL, FALSE);
      /* We must not cache anything from the preliminary sizing.  */
      lang_reset_memory_regions ();
    }
}

static void
ppc_before_allocation (void)
{
  if (is_ppc_elf (link_info.output_bfd))
    {
      if (!no_inline_opt
	  && !bfd_link_relocatable (&link_info))
	{
	  prelim_size_sections ();

	  if (!ppc_elf_inline_plt (&link_info))
	    einfo (_("%X%P: inline PLT: %E\n"));
	}

      if (ppc_elf_tls_setup (link_info.output_bfd, &link_info)
	  && !notlsopt)
	{
	  if (!ppc_elf_tls_optimize (link_info.output_bfd, &link_info))
	    {
	      einfo (_("%X%P: TLS problem %E\n"));
	      return;
	    }
	}
    }

  gld${EMULATION_NAME}_before_allocation ();

  ppc_elf_maybe_strip_sdata_syms (&link_info);

  if (RELAXATION_ENABLED)
    params.branch_trampolines = 1;

  /* Turn on relaxation if executable sections have addresses that
     might make branches overflow.  */
  else if (!RELAXATION_DISABLED_BY_USER)
    {
      bfd_vma low = (bfd_vma) -1;
      bfd_vma high = 0;
      asection *o;

      /* Run lang_size_sections even if already done, so as to pick
	 up gld${EMULATION_NAME}_before_allocation sizing.  This
	 matters when we have an executable bss plt which will
	 typically be laid out near the end of the image, ie. worst
	 case for branches at the start of .text.  */
      expld.phase = lang_first_phase_enum;
      prelim_size_sections ();

      for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
	{
	  if ((o->flags & (SEC_ALLOC | SEC_CODE)) != (SEC_ALLOC | SEC_CODE))
	    continue;
	  if (o->rawsize == 0)
	    continue;
	  if (low > o->vma)
	    low = o->vma;
	  if (high < o->vma + o->rawsize - 1)
	    high = o->vma + o->rawsize - 1;
	}
      if (high > low && high - low > (1 << 25) - 1)
	params.branch_trampolines = 1;
    }

  if (params.branch_trampolines
      || params.ppc476_workaround
      || params.pic_fixup > 0)
    ENABLE_RELAXATION;
}

/* Replaces default zero fill padding in executable sections with
   "ba 0" instructions.  This works around the ppc476 icache bug if we
   have a function pointer tail call near the end of a page, some
   small amount of padding, then the function called at the beginning
   of the next page.  If the "ba 0" is ever executed we should hit a
   segv, so it's almost as good as an illegal instruction (zero).  */

static void
no_zero_padding (lang_statement_union_type *l)
{
  if (l->header.type == lang_padding_statement_enum
      && l->padding_statement.size != 0
      && l->padding_statement.output_section != NULL
      && (l->padding_statement.output_section->flags & SEC_CODE) != 0
      && l->padding_statement.fill->size == 0)
    {
      struct _ppc_fill_type
      {
	size_t size;
	unsigned char data[4];
      };
      static struct _ppc_fill_type fill_be = { 4, {0x48, 0, 0, 2} };
      static struct _ppc_fill_type fill_le = { 4, {2, 0, 0, 0x48} };

      if (bfd_big_endian (link_info.output_bfd))
	l->padding_statement.fill = (struct _fill_type *) &fill_be;
      else
	l->padding_statement.fill = (struct _fill_type *) &fill_le;
    }
}

static void
ppc_finish (void)
{
  if (params.ppc476_workaround)
    lang_for_each_statement (no_zero_padding);
  if (!ppc_finish_symbols (&link_info))
    einfo (_("%X%P: ppc_finish_symbols problem %E\n"));
  finish_default ();
}

EOF

if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
  fragment <<EOF
/* Special handling for embedded SPU executables.  */
extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *);

static bfd_boolean
ppc_recognized_file (lang_input_statement_type *entry)
{
  if (embedded_spu_file (entry, "-m32"))
    return TRUE;

  return ldelf_load_symbols (entry);
}

EOF
LDEMUL_RECOGNIZED_FILE=ppc_recognized_file
fi

# Define some shell vars to insert bits of code into the standard elf
# parse_args and list_options functions.
#
PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}'
enum ppc32_opt
{
  OPTION_NO_TLS_OPT = 321,
  OPTION_NO_TLS_GET_ADDR_OPT,
  OPTION_NEW_PLT,
  OPTION_OLD_PLT,
  OPTION_PLT_ALIGN,
  OPTION_NO_PLT_ALIGN,
  OPTION_NO_INLINE_OPT,
  OPTION_OLD_GOT,
  OPTION_STUBSYMS,
  OPTION_NO_STUBSYMS,
  OPTION_PPC476_WORKAROUND,
  OPTION_NO_PPC476_WORKAROUND,
  OPTION_NO_PICFIXUP,
  OPTION_VLE_RELOC_FIXUP
};
'

PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
  { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
  { "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
  { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
  { "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT },'
if test -z "$VXWORKS_BASE_EM_FILE" ; then
  PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
  { "secure-plt", no_argument, NULL, OPTION_NEW_PLT },
  { "bss-plt", no_argument, NULL, OPTION_OLD_PLT },
  { "plt-align", optional_argument, NULL, OPTION_PLT_ALIGN },
  { "no-plt-align", no_argument, NULL, OPTION_NO_PLT_ALIGN },
  { "no-inline-optimize", no_argument, NULL, OPTION_NO_INLINE_OPT },
  { "sdata-got", no_argument, NULL, OPTION_OLD_GOT },'
fi
PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
  { "ppc476-workaround", optional_argument, NULL, OPTION_PPC476_WORKAROUND },
  { "no-ppc476-workaround", no_argument, NULL, OPTION_NO_PPC476_WORKAROUND },
  { "no-pic-fixup", no_argument, NULL, OPTION_NO_PICFIXUP },
  { "vle-reloc-fixup", no_argument, NULL, OPTION_VLE_RELOC_FIXUP },
'

PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'
  fprintf (file, _("\
  --emit-stub-syms            Label linker stubs with a symbol\n"
		   ));
  fprintf (file, _("\
  --no-emit-stub-syms         Don'\''t label linker stubs with a symbol\n"
		   ));
  fprintf (file, _("\
  --no-tls-optimize           Don'\''t try to optimize TLS accesses\n"
		   ));
  fprintf (file, _("\
  --no-tls-get-addr-optimize  Don'\''t use a special __tls_get_addr call\n"
		   ));'
if test -z "$VXWORKS_BASE_EM_FILE" ; then
  PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'\
  fprintf (file, _("\
  --secure-plt                Use new-style PLT if possible\n"
		   ));
  fprintf (file, _("\
  --bss-plt                   Force old-style BSS PLT\n"
		   ));
  fprintf (file, _("\
  --plt-align                 Align PLT call stubs to fit cache lines\n"
		   ));
  fprintf (file, _("\
  --no-plt-align              Dont'\''t align individual PLT call stubs\n"
		   ));
  fprintf (file, _("\
  --no-inline-optimize        Don'\''t convert inline PLT to direct calls\n"
		   ));
  fprintf (file, _("\
  --sdata-got                 Force GOT location just before .sdata\n"
		   ));'
fi
PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'\
  fprintf (file, _("\
  --ppc476-workaround [=pagesize]\n\
                              Avoid a cache bug on ppc476\n"
		   ));
  fprintf (file, _("\
  --no-ppc476-workaround      Disable workaround\n"
		   ));
  fprintf (file, _("\
  --no-pic-fixup              Don'\''t edit non-pic to pic\n"
		   ));
  fprintf (file, _("\
  --vle-reloc-fixup           Correct old object file 16A/16D relocation\n"
		   ));
'

PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}'
    case OPTION_STUBSYMS:
      params.emit_stub_syms = 1;
      break;

    case OPTION_NO_STUBSYMS:
      params.emit_stub_syms = 0;
      break;

    case OPTION_NO_TLS_OPT:
      notlsopt = 1;
      break;

    case OPTION_NO_TLS_GET_ADDR_OPT:
      params.no_tls_get_addr_opt = 1;
      break;

    case OPTION_NEW_PLT:
      params.plt_style = PLT_NEW;
      break;

    case OPTION_OLD_PLT:
      params.plt_style = PLT_OLD;
      break;

    case OPTION_PLT_ALIGN:
      if (optarg != NULL)
	{
	  char *end;
	  unsigned long val = strtoul (optarg, &end, 0);
	  if (*end || val > 5)
	    einfo (_("%F%P: invalid --plt-align `%s'\''\n"), optarg);
	  params.plt_stub_align = val;
	}
      else
	params.plt_stub_align = 5;
      break;

    case OPTION_NO_PLT_ALIGN:
      params.plt_stub_align = 0;
      break;

    case OPTION_NO_INLINE_OPT:
      no_inline_opt = 1;
      break;

    case OPTION_OLD_GOT:
      old_got = 1;
      break;

    case OPTION_TRADITIONAL_FORMAT:
      notlsopt = 1;
      params.no_tls_get_addr_opt = 1;
      return FALSE;

    case OPTION_PPC476_WORKAROUND:
      params.ppc476_workaround = 1;
      if (optarg != NULL)
	{
	  char *end;
	  params.pagesize = strtoul (optarg, &end, 0);
	  if (*end
	      || (params.pagesize < 4096 && params.pagesize != 0)
	      || params.pagesize != (params.pagesize & -params.pagesize))
	    einfo (_("%F%P: invalid pagesize `%s'\''\n"), optarg);
	}
      break;

    case OPTION_NO_PPC476_WORKAROUND:
      params.ppc476_workaround = 0;
      break;

    case OPTION_NO_PICFIXUP:
      params.pic_fixup = -1;
      break;

    case OPTION_VLE_RELOC_FIXUP:
      params.vle_reloc_fixup = 1;
      break;
'

# Put these extra ppc32elf routines in ld_${EMULATION_NAME}_emulation
#
LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_after_open_output
if test -z "$VXWORKS_BASE_EM_FILE" ; then
  LDEMUL_AFTER_CHECK_RELOCS=ppc_after_check_relocs
fi
LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
LDEMUL_FINISH=ppc_finish
Commit	Line	Data
	1	# This shell script emits a C file. -- C --
	2	# Copyright (C) 2003-2020 Free Software Foundation, Inc.
	3	#
	4	# This file is part of the GNU Binutils.
	5	#
	6	# This program is free software; you can redistribute it and/or modify
	7	# it under the terms of the GNU General Public License as published by
	8	# the Free Software Foundation; either version 3 of the License, or
	9	# (at your option) any later version.
	10	#
	11	# This program is distributed in the hope that it will be useful,
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	# GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License
	17	# along with this program; if not, write to the Free Software
	18	# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	19	# MA 02110-1301, USA.
	20	#
	21
	22	# This file is sourced from elf.em, and defines extra powerpc32-elf
	23	# specific routines.
	24	#
	25	fragment <<EOF
	26
	27	#include "elf32-ppc.h"
	28	#include "ldlex.h"
	29	#include "ldlang.h"
	30
	31	#define is_ppc_elf(bfd) \
	32	(bfd_get_flavour (bfd) == bfd_target_elf_flavour \
	33	&& elf_object_id (bfd) == PPC32_ELF_DATA)
	34
	35	/* Whether to run tls optimization. */
	36	static int notlsopt = 0;
	37
	38	/* Whether to convert inline PLT calls to direct. */
	39	static int no_inline_opt = 0;
	40
	41	/* Choose the correct place for .got. */
	42	static int old_got = 0;
	43
	44	static struct ppc_elf_params params = { PLT_UNSET, 0, -1,
	45	0, 0, 0, 0, 0, 0, 0 };
	46
	47	static void
	48	ppc_after_open_output (void)
	49	{
	50	if (params.emit_stub_syms < 0)
	51	params.emit_stub_syms = (link_info.emitrelocations
	52	\|\| bfd_link_pic (&link_info));
	53	if (params.pagesize == 0)
	54	params.pagesize = config.commonpagesize;
	55	ppc_elf_link_params (&link_info, &params);
	56	}
	57
	58	EOF
	59
	60	# No --secure-plt, --bss-plt, or --sdata-got for vxworks.
	61	if test -z "$VXWORKS_BASE_EM_FILE" ; then
	62	fragment <<EOF
	63	static void
	64	ppc_after_check_relocs (void)
	65	{
	66	if (is_ppc_elf (link_info.output_bfd))
	67	{
	68	int new_plt;
	69	int keep_new;
	70	unsigned int num_plt;
	71	unsigned int num_got;
	72	lang_output_section_statement_type *os;
	73	lang_output_section_statement_type *plt_os[2];
	74	lang_output_section_statement_type *got_os[2];
	75
	76	new_plt = ppc_elf_select_plt_layout (link_info.output_bfd, &link_info);
	77	if (new_plt < 0)
	78	einfo (_("%X%P: select_plt_layout problem %E\n"));
	79
	80	num_got = 0;
	81	num_plt = 0;
	82	for (os = (void *) lang_os_list.head;
	83	os != NULL;
	84	os = os->next)
	85	{
	86	if (os->constraint == SPECIAL && strcmp (os->name, ".plt") == 0)
	87	{
	88	if (num_plt < 2)
	89	plt_os[num_plt] = os;
	90	++num_plt;
	91	}
	92	if (os->constraint == SPECIAL && strcmp (os->name, ".got") == 0)
	93	{
	94	if (num_got < 2)
	95	got_os[num_got] = os;
	96	++num_got;
	97	}
	98	}
	99
	100	keep_new = new_plt == 1 ? 0 : -1;
	101	if (num_plt == 2)
	102	{
	103	plt_os[0]->constraint = keep_new;
	104	plt_os[1]->constraint = ~keep_new;
	105	}
	106	if (num_got == 2)
	107	{
	108	if (old_got)
	109	keep_new = -1;
	110	got_os[0]->constraint = keep_new;
	111	got_os[1]->constraint = ~keep_new;
	112	}
	113	}
	114
	115	after_check_relocs_default ();
	116	}
	117
	118	EOF
	119	fi
	120	fragment <<EOF
	121	static void
	122	prelim_size_sections (void)
	123	{
	124	if (expld.phase != lang_mark_phase_enum)
	125	{
	126	expld.phase = lang_mark_phase_enum;
	127	expld.dataseg.phase = exp_seg_none;
	128	one_lang_size_sections_pass (NULL, FALSE);
	129	/* We must not cache anything from the preliminary sizing. */
	130	lang_reset_memory_regions ();
	131	}
	132	}
	133
	134	static void
	135	ppc_before_allocation (void)
	136	{
	137	if (is_ppc_elf (link_info.output_bfd))
	138	{
	139	if (!no_inline_opt
	140	&& !bfd_link_relocatable (&link_info))
	141	{
	142	prelim_size_sections ();
	143
	144	if (!ppc_elf_inline_plt (&link_info))
	145	einfo (_("%X%P: inline PLT: %E\n"));
	146	}
	147
	148	if (ppc_elf_tls_setup (link_info.output_bfd, &link_info)
	149	&& !notlsopt)
	150	{
	151	if (!ppc_elf_tls_optimize (link_info.output_bfd, &link_info))
	152	{
	153	einfo (_("%X%P: TLS problem %E\n"));
	154	return;
	155	}
	156	}
	157	}
	158
	159	gld${EMULATION_NAME}_before_allocation ();
	160
	161	ppc_elf_maybe_strip_sdata_syms (&link_info);
	162
	163	if (RELAXATION_ENABLED)
	164	params.branch_trampolines = 1;
	165
	166	/* Turn on relaxation if executable sections have addresses that
	167	might make branches overflow. */
	168	else if (!RELAXATION_DISABLED_BY_USER)
	169	{
	170	bfd_vma low = (bfd_vma) -1;
	171	bfd_vma high = 0;
	172	asection *o;
	173
	174	/* Run lang_size_sections even if already done, so as to pick
	175	up gld${EMULATION_NAME}_before_allocation sizing. This
	176	matters when we have an executable bss plt which will
	177	typically be laid out near the end of the image, ie. worst
	178	case for branches at the start of .text. */
	179	expld.phase = lang_first_phase_enum;
	180	prelim_size_sections ();
	181
	182	for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
	183	{
	184	if ((o->flags & (SEC_ALLOC \| SEC_CODE)) != (SEC_ALLOC \| SEC_CODE))
	185	continue;
	186	if (o->rawsize == 0)
	187	continue;
	188	if (low > o->vma)
	189	low = o->vma;
	190	if (high < o->vma + o->rawsize - 1)
	191	high = o->vma + o->rawsize - 1;
	192	}
	193	if (high > low && high - low > (1 << 25) - 1)
	194	params.branch_trampolines = 1;
	195	}
	196
	197	if (params.branch_trampolines
	198	\|\| params.ppc476_workaround
	199	\|\| params.pic_fixup > 0)
	200	ENABLE_RELAXATION;
	201	}
	202
	203	/* Replaces default zero fill padding in executable sections with
	204	"ba 0" instructions. This works around the ppc476 icache bug if we
	205	have a function pointer tail call near the end of a page, some
	206	small amount of padding, then the function called at the beginning
	207	of the next page. If the "ba 0" is ever executed we should hit a
	208	segv, so it's almost as good as an illegal instruction (zero). */
	209
	210	static void
	211	no_zero_padding (lang_statement_union_type *l)
	212	{
	213	if (l->header.type == lang_padding_statement_enum
	214	&& l->padding_statement.size != 0
	215	&& l->padding_statement.output_section != NULL
	216	&& (l->padding_statement.output_section->flags & SEC_CODE) != 0
	217	&& l->padding_statement.fill->size == 0)
	218	{
	219	struct _ppc_fill_type
	220	{
	221	size_t size;
	222	unsigned char data[4];
	223	};
	224	static struct _ppc_fill_type fill_be = { 4, {0x48, 0, 0, 2} };
	225	static struct _ppc_fill_type fill_le = { 4, {2, 0, 0, 0x48} };
	226
	227	if (bfd_big_endian (link_info.output_bfd))
	228	l->padding_statement.fill = (struct _fill_type *) &fill_be;
	229	else
	230	l->padding_statement.fill = (struct _fill_type *) &fill_le;
	231	}
	232	}
	233
	234	static void
	235	ppc_finish (void)
	236	{
	237	if (params.ppc476_workaround)
	238	lang_for_each_statement (no_zero_padding);
	239	if (!ppc_finish_symbols (&link_info))
	240	einfo (_("%X%P: ppc_finish_symbols problem %E\n"));
	241	finish_default ();
	242	}
	243
	244	EOF
	245
	246	if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
	247	fragment <<EOF
	248	/* Special handling for embedded SPU executables. */
	249	extern bfd_boolean embedded_spu_file (lang_input_statement_type , const char );
	250
	251	static bfd_boolean
	252	ppc_recognized_file (lang_input_statement_type *entry)
	253	{
	254	if (embedded_spu_file (entry, "-m32"))
	255	return TRUE;
	256
	257	return ldelf_load_symbols (entry);
	258	}
	259
	260	EOF
	261	LDEMUL_RECOGNIZED_FILE=ppc_recognized_file
	262	fi
	263
	264	# Define some shell vars to insert bits of code into the standard elf
	265	# parse_args and list_options functions.
	266	#
	267	PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}'
	268	enum ppc32_opt
	269	{
	270	OPTION_NO_TLS_OPT = 321,
	271	OPTION_NO_TLS_GET_ADDR_OPT,
	272	OPTION_NEW_PLT,
	273	OPTION_OLD_PLT,
	274	OPTION_PLT_ALIGN,
	275	OPTION_NO_PLT_ALIGN,
	276	OPTION_NO_INLINE_OPT,
	277	OPTION_OLD_GOT,
	278	OPTION_STUBSYMS,
	279	OPTION_NO_STUBSYMS,
	280	OPTION_PPC476_WORKAROUND,
	281	OPTION_NO_PPC476_WORKAROUND,
	282	OPTION_NO_PICFIXUP,
	283	OPTION_VLE_RELOC_FIXUP
	284	};
	285	'
	286
	287	PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
	288	{ "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
	289	{ "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
	290	{ "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
	291	{ "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT },'
	292	if test -z "$VXWORKS_BASE_EM_FILE" ; then
	293	PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
	294	{ "secure-plt", no_argument, NULL, OPTION_NEW_PLT },
	295	{ "bss-plt", no_argument, NULL, OPTION_OLD_PLT },
	296	{ "plt-align", optional_argument, NULL, OPTION_PLT_ALIGN },
	297	{ "no-plt-align", no_argument, NULL, OPTION_NO_PLT_ALIGN },
	298	{ "no-inline-optimize", no_argument, NULL, OPTION_NO_INLINE_OPT },
	299	{ "sdata-got", no_argument, NULL, OPTION_OLD_GOT },'
	300	fi
	301	PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
	302	{ "ppc476-workaround", optional_argument, NULL, OPTION_PPC476_WORKAROUND },
	303	{ "no-ppc476-workaround", no_argument, NULL, OPTION_NO_PPC476_WORKAROUND },
	304	{ "no-pic-fixup", no_argument, NULL, OPTION_NO_PICFIXUP },
	305	{ "vle-reloc-fixup", no_argument, NULL, OPTION_VLE_RELOC_FIXUP },
	306	'
	307
	308	PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'
	309	fprintf (file, _("\
	310	--emit-stub-syms Label linker stubs with a symbol\n"
	311	));
	312	fprintf (file, _("\
	313	--no-emit-stub-syms Don'\''t label linker stubs with a symbol\n"
	314	));
	315	fprintf (file, _("\
	316	--no-tls-optimize Don'\''t try to optimize TLS accesses\n"
	317	));
	318	fprintf (file, _("\
	319	--no-tls-get-addr-optimize Don'\''t use a special __tls_get_addr call\n"
	320	));'
	321	if test -z "$VXWORKS_BASE_EM_FILE" ; then
	322	PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'\
	323	fprintf (file, _("\
	324	--secure-plt Use new-style PLT if possible\n"
	325	));
	326	fprintf (file, _("\
	327	--bss-plt Force old-style BSS PLT\n"
	328	));
	329	fprintf (file, _("\
	330	--plt-align Align PLT call stubs to fit cache lines\n"
	331	));
	332	fprintf (file, _("\
	333	--no-plt-align Dont'\''t align individual PLT call stubs\n"
	334	));
	335	fprintf (file, _("\
	336	--no-inline-optimize Don'\''t convert inline PLT to direct calls\n"
	337	));
	338	fprintf (file, _("\
	339	--sdata-got Force GOT location just before .sdata\n"
	340	));'
	341	fi
	342	PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'\
	343	fprintf (file, _("\
	344	--ppc476-workaround [=pagesize]\n\
	345	Avoid a cache bug on ppc476\n"
	346	));
	347	fprintf (file, _("\
	348	--no-ppc476-workaround Disable workaround\n"
	349	));
	350	fprintf (file, _("\
	351	--no-pic-fixup Don'\''t edit non-pic to pic\n"
	352	));
	353	fprintf (file, _("\
	354	--vle-reloc-fixup Correct old object file 16A/16D relocation\n"
	355	));
	356	'
	357
	358	PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}'
	359	case OPTION_STUBSYMS:
	360	params.emit_stub_syms = 1;
	361	break;
	362
	363	case OPTION_NO_STUBSYMS:
	364	params.emit_stub_syms = 0;
	365	break;
	366
	367	case OPTION_NO_TLS_OPT:
	368	notlsopt = 1;
	369	break;
	370
	371	case OPTION_NO_TLS_GET_ADDR_OPT:
	372	params.no_tls_get_addr_opt = 1;
	373	break;
	374
	375	case OPTION_NEW_PLT:
	376	params.plt_style = PLT_NEW;
	377	break;
	378
	379	case OPTION_OLD_PLT:
	380	params.plt_style = PLT_OLD;
	381	break;
	382
	383	case OPTION_PLT_ALIGN:
	384	if (optarg != NULL)
	385	{
	386	char *end;
	387	unsigned long val = strtoul (optarg, &end, 0);
	388	if (*end \|\| val > 5)
	389	einfo (_("%F%P: invalid --plt-align `%s'\''\n"), optarg);
	390	params.plt_stub_align = val;
	391	}
	392	else
	393	params.plt_stub_align = 5;
	394	break;
	395
	396	case OPTION_NO_PLT_ALIGN:
	397	params.plt_stub_align = 0;
	398	break;
	399
	400	case OPTION_NO_INLINE_OPT:
	401	no_inline_opt = 1;
	402	break;
	403
	404	case OPTION_OLD_GOT:
	405	old_got = 1;
	406	break;
	407
	408	case OPTION_TRADITIONAL_FORMAT:
	409	notlsopt = 1;
	410	params.no_tls_get_addr_opt = 1;
	411	return FALSE;
	412
	413	case OPTION_PPC476_WORKAROUND:
	414	params.ppc476_workaround = 1;
	415	if (optarg != NULL)
	416	{
	417	char *end;
	418	params.pagesize = strtoul (optarg, &end, 0);
	419	if (*end
	420	\|\| (params.pagesize < 4096 && params.pagesize != 0)
	421	\|\| params.pagesize != (params.pagesize & -params.pagesize))
	422	einfo (_("%F%P: invalid pagesize `%s'\''\n"), optarg);
	423	}
	424	break;
	425
	426	case OPTION_NO_PPC476_WORKAROUND:
	427	params.ppc476_workaround = 0;
	428	break;
	429
	430	case OPTION_NO_PICFIXUP:
	431	params.pic_fixup = -1;
	432	break;
	433
	434	case OPTION_VLE_RELOC_FIXUP:
	435	params.vle_reloc_fixup = 1;
	436	break;
	437	'
	438
	439	# Put these extra ppc32elf routines in ld_${EMULATION_NAME}_emulation
	440	#
	441	LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_after_open_output
	442	if test -z "$VXWORKS_BASE_EM_FILE" ; then
	443	LDEMUL_AFTER_CHECK_RELOCS=ppc_after_check_relocs
	444	fi
	445	LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
	446	LDEMUL_FINISH=ppc_finish