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

# This shell script emits a C file. -*- C -*-
#   Copyright (C) 2003-2021 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 = link_info.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
f9e6bfa8	1	# This shell script emits a C file. -- C --
250d07de	2	# Copyright (C) 2003-2021 Free Software Foundation, Inc.
f9e6bfa8	3	#
f96b4a7b	4	# This file is part of the GNU Binutils.
f9e6bfa8 AM	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
f96b4a7b	8	# the Free Software Foundation; either version 3 of the License, or
f9e6bfa8 AM	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
f96b4a7b NC	18	# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
f96b4a7b NC	19	# MA 02110-1301, USA.
f9e6bfa8 AM	20	#
f9e6bfa8 AM	21
075a2b89	22	# This file is sourced from elf.em, and defines extra powerpc32-elf
f9e6bfa8 AM	23	# specific routines.
f9e6bfa8 AM	24	#
92b93329	25	fragment <<EOF
f9e6bfa8	26
f9e6bfa8	27	#include "elf32-ppc.h"
f05eb3b7	28	#include "ldlex.h"
b4ab4364	29	#include "ldlang.h"
f9e6bfa8	30
5503fea1 AM	31	#define is_ppc_elf(bfd) \
5503fea1 AM	32	(bfd_get_flavour (bfd) == bfd_target_elf_flavour \
4dfe6ac6	33	&& elf_object_id (bfd) == PPC32_ELF_DATA)
c9a2f333	34
f9e6bfa8 AM	35	/* Whether to run tls optimization. */
	36	static int notlsopt = 0;
	37
3e04d765 AM	38	/* Whether to convert inline PLT calls to direct. */
	39	static int no_inline_opt = 0;
	40
5446cbdf	41	/* Choose the correct place for .got. */
0cf7d72c AM	42	static int old_got = 0;
0cf7d72c AM	43
407aa07c	44	static struct ppc_elf_params params = { PLT_UNSET, 0, -1,
9e390558	45	0, 0, 0, 0, 0, 0, 0 };
5446cbdf AM	46
	47	static void
	48	ppc_after_open_output (void)
	49	{
	50	if (params.emit_stub_syms < 0)
0e1862bb L	51	params.emit_stub_syms = (link_info.emitrelocations
0e1862bb L	52	\|\| bfd_link_pic (&link_info));
76e7a751	53	if (params.pagesize == 0)
c410035d	54	params.pagesize = link_info.commonpagesize;
5446cbdf AM	55	ppc_elf_link_params (&link_info, &params);
	56	}
	57
db434ba0 AM	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
0cf7d72c	63	static void
5c3261b0	64	ppc_after_check_relocs (void)
0cf7d72c	65	{
5503fea1	66	if (is_ppc_elf (link_info.output_bfd))
0cf7d72c AM	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
5446cbdf	76	new_plt = ppc_elf_select_plt_layout (link_info.output_bfd, &link_info);
0cf7d72c	77	if (new_plt < 0)
d003af55	78	einfo (_("%X%P: select_plt_layout problem %E\n"));
0cf7d72c AM	79
	80	num_got = 0;
	81	num_plt = 0;
8ce18f9c	82	for (os = (void *) lang_os_list.head;
0cf7d72c AM	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
5c3261b0	115	after_check_relocs_default ();
0cf7d72c AM	116	}
0cf7d72c AM	117
db434ba0 AM	118	EOF
	119	fi
	120	fragment <<EOF
3e04d765 AM	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
f9e6bfa8	134	static void
7e5d8d48	135	ppc_before_allocation (void)
f9e6bfa8	136	{
5503fea1	137	if (is_ppc_elf (link_info.output_bfd))
f9e6bfa8	138	{
3e04d765 AM	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
5446cbdf	148	if (ppc_elf_tls_setup (link_info.output_bfd, &link_info)
a7f2871e	149	&& !notlsopt)
f9e6bfa8	150	{
f13a99db	151	if (!ppc_elf_tls_optimize (link_info.output_bfd, &link_info))
f9e6bfa8	152	{
d003af55	153	einfo (_("%X%P: TLS problem %E\n"));
f9e6bfa8 AM	154	return;
	155	}
	156	}
	157	}
4135c73b	158
f9e6bfa8	159	gld${EMULATION_NAME}_before_allocation ();
4135c73b	160
93d1b056 AM	161	ppc_elf_maybe_strip_sdata_syms (&link_info);
93d1b056 AM	162
5446cbdf AM	163	if (RELAXATION_ENABLED)
	164	params.branch_trampolines = 1;
	165
4135c73b AM	166	/* Turn on relaxation if executable sections have addresses that
4135c73b AM	167	might make branches overflow. */
5446cbdf	168	else if (!RELAXATION_DISABLED_BY_USER)
4135c73b AM	169	{
	170	bfd_vma low = (bfd_vma) -1;
	171	bfd_vma high = 0;
	172	asection *o;
	173
7df6aecc AM	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;
3e04d765	180	prelim_size_sections ();
4135c73b AM	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;
07088e95	186	if (o->rawsize == 0)
4135c73b AM	187	continue;
	188	if (low > o->vma)
	189	low = o->vma;
07088e95 AM	190	if (high < o->vma + o->rawsize - 1)
07088e95 AM	191	high = o->vma + o->rawsize - 1;
4135c73b AM	192	}
4135c73b AM	193	if (high > low && high - low > (1 << 25) - 1)
5446cbdf	194	params.branch_trampolines = 1;
4135c73b	195	}
5446cbdf	196
d3e454b9 AM	197	if (params.branch_trampolines
	198	\|\| params.ppc476_workaround
	199	\|\| params.pic_fixup > 0)
5446cbdf	200	ENABLE_RELAXATION;
f9e6bfa8 AM	201	}
f9e6bfa8 AM	202
b4ab4364 AM	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);
49c09209 AM	239	if (!ppc_finish_symbols (&link_info))
49c09209 AM	240	einfo (_("%X%P: ppc_finish_symbols problem %E\n"));
b4ab4364 AM	241	finish_default ();
	242	}
	243
f9e6bfa8 AM	244	EOF
f9e6bfa8 AM	245
dc27aea4	246	if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
92b93329	247	fragment <<EOF
dc27aea4 AM	248	/* Special handling for embedded SPU executables. */
dc27aea4 AM	249	extern bfd_boolean embedded_spu_file (lang_input_statement_type , const char );
dc27aea4 AM	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
d871d478	257	return ldelf_load_symbols (entry);
dc27aea4 AM	258	}
	259
	260	EOF
	261	LDEMUL_RECOGNIZED_FILE=ppc_recognized_file
	262	fi
	263
f9e6bfa8 AM	264	# Define some shell vars to insert bits of code into the standard elf
	265	# parse_args and list_options functions.
	266	#
58d180e8	267	PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}'
9e390558 AM	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,
3e04d765	276	OPTION_NO_INLINE_OPT,
9e390558 AM	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	};
f9e6bfa8 AM	285	'
f9e6bfa8 AM	286
58d180e8	287	PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
0ba07910	288	{ "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
b02c4cfa	289	{ "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
f9e6bfa8	290	{ "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
db434ba0 AM	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}'
016687f8	294	{ "secure-plt", no_argument, NULL, OPTION_NEW_PLT },
0cf7d72c	295	{ "bss-plt", no_argument, NULL, OPTION_OLD_PLT },
691d2e9a	296	{ "plt-align", optional_argument, NULL, OPTION_PLT_ALIGN },
9e390558	297	{ "no-plt-align", no_argument, NULL, OPTION_NO_PLT_ALIGN },
3e04d765	298	{ "no-inline-optimize", no_argument, NULL, OPTION_NO_INLINE_OPT },
db434ba0 AM	299	{ "sdata-got", no_argument, NULL, OPTION_OLD_GOT },'
	300	fi
	301	PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
5446cbdf AM	302	{ "ppc476-workaround", optional_argument, NULL, OPTION_PPC476_WORKAROUND },
5446cbdf AM	303	{ "no-ppc476-workaround", no_argument, NULL, OPTION_NO_PPC476_WORKAROUND },
d3e454b9	304	{ "no-pic-fixup", no_argument, NULL, OPTION_NO_PICFIXUP },
08dc996f	305	{ "vle-reloc-fixup", no_argument, NULL, OPTION_VLE_RELOC_FIXUP },
f9e6bfa8 AM	306	'
f9e6bfa8 AM	307
58d180e8	308	PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'
f9e6bfa8	309	fprintf (file, _("\
df5f2391	310	--emit-stub-syms Label linker stubs with a symbol\n"
9e390558 AM	311	));
9e390558 AM	312	fprintf (file, _("\
df5f2391	313	--no-emit-stub-syms Don'\''t label linker stubs with a symbol\n"
9e390558 AM	314	));
9e390558 AM	315	fprintf (file, _("\
df5f2391	316	--no-tls-optimize Don'\''t try to optimize TLS accesses\n"
9e390558 AM	317	));
9e390558 AM	318	fprintf (file, _("\
df5f2391	319	--no-tls-get-addr-optimize Don'\''t use a special __tls_get_addr call\n"
9e390558	320	));'
db434ba0 AM	321	if test -z "$VXWORKS_BASE_EM_FILE" ; then
db434ba0 AM	322	PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'\
9e390558	323	fprintf (file, _("\
df5f2391	324	--secure-plt Use new-style PLT if possible\n"
9e390558 AM	325	));
9e390558 AM	326	fprintf (file, _("\
df5f2391	327	--bss-plt Force old-style BSS PLT\n"
9e390558 AM	328	));
9e390558 AM	329	fprintf (file, _("\
df5f2391	330	--plt-align Align PLT call stubs to fit cache lines\n"
9e390558 AM	331	));
9e390558 AM	332	fprintf (file, _("\
df5f2391	333	--no-plt-align Dont'\''t align individual PLT call stubs\n"
9e390558 AM	334	));
9e390558 AM	335	fprintf (file, _("\
3e04d765 AM	336	--no-inline-optimize Don'\''t convert inline PLT to direct calls\n"
	337	));
	338	fprintf (file, _("\
df5f2391	339	--sdata-got Force GOT location just before .sdata\n"
9e390558	340	));'
db434ba0 AM	341	fi
db434ba0 AM	342	PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'\
9e390558	343	fprintf (file, _("\
5446cbdf	344	--ppc476-workaround [=pagesize]\n\
df5f2391	345	Avoid a cache bug on ppc476\n"
9e390558 AM	346	));
9e390558 AM	347	fprintf (file, _("\
df5f2391	348	--no-ppc476-workaround Disable workaround\n"
9e390558 AM	349	));
9e390558 AM	350	fprintf (file, _("\
df5f2391	351	--no-pic-fixup Don'\''t edit non-pic to pic\n"
9e390558 AM	352	));
9e390558 AM	353	fprintf (file, _("\
df5f2391	354	--vle-reloc-fixup Correct old object file 16A/16D relocation\n"
f9e6bfa8 AM	355	));
	356	'
	357
58d180e8	358	PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}'
0ba07910	359	case OPTION_STUBSYMS:
5446cbdf	360	params.emit_stub_syms = 1;
0ba07910 AM	361	break;
0ba07910 AM	362
b02c4cfa	363	case OPTION_NO_STUBSYMS:
5446cbdf	364	params.emit_stub_syms = 0;
b02c4cfa AM	365	break;
b02c4cfa AM	366
f9e6bfa8 AM	367	case OPTION_NO_TLS_OPT:
	368	notlsopt = 1;
	369	break;
0cf7d72c	370
a7f2871e	371	case OPTION_NO_TLS_GET_ADDR_OPT:
5446cbdf	372	params.no_tls_get_addr_opt = 1;
a7f2871e AM	373	break;
a7f2871e AM	374
016687f8	375	case OPTION_NEW_PLT:
5446cbdf	376	params.plt_style = PLT_NEW;
016687f8 AM	377	break;
016687f8 AM	378
0cf7d72c	379	case OPTION_OLD_PLT:
5446cbdf	380	params.plt_style = PLT_OLD;
0cf7d72c AM	381	break;
0cf7d72c AM	382
9e390558	383	case OPTION_PLT_ALIGN:
691d2e9a AM	384	if (optarg != NULL)
	385	{
	386	char *end;
	387	unsigned long val = strtoul (optarg, &end, 0);
	388	if (*end \|\| val > 5)
df5f2391	389	einfo (_("%F%P: invalid --plt-align `%s'\''\n"), optarg);
691d2e9a AM	390	params.plt_stub_align = val;
	391	}
	392	else
	393	params.plt_stub_align = 5;
9e390558 AM	394	break;
	395
	396	case OPTION_NO_PLT_ALIGN:
	397	params.plt_stub_align = 0;
	398	break;
	399
3e04d765 AM	400	case OPTION_NO_INLINE_OPT:
	401	no_inline_opt = 1;
	402	break;
	403
0cf7d72c AM	404	case OPTION_OLD_GOT:
	405	old_got = 1;
	406	break;
f05eb3b7 AM	407
	408	case OPTION_TRADITIONAL_FORMAT:
	409	notlsopt = 1;
5446cbdf	410	params.no_tls_get_addr_opt = 1;
f05eb3b7	411	return FALSE;
5446cbdf AM	412
	413	case OPTION_PPC476_WORKAROUND:
	414	params.ppc476_workaround = 1;
	415	if (optarg != NULL)
	416	{
	417	char *end;
76e7a751	418	params.pagesize = strtoul (optarg, &end, 0);
5446cbdf	419	if (*end
76e7a751 AM	420	\|\| (params.pagesize < 4096 && params.pagesize != 0)
76e7a751 AM	421	\|\| params.pagesize != (params.pagesize & -params.pagesize))
df5f2391	422	einfo (_("%F%P: invalid pagesize `%s'\''\n"), optarg);
5446cbdf AM	423	}
	424	break;
	425
	426	case OPTION_NO_PPC476_WORKAROUND:
	427	params.ppc476_workaround = 0;
	428	break;
d3e454b9 AM	429
	430	case OPTION_NO_PICFIXUP:
	431	params.pic_fixup = -1;
	432	break;
08dc996f AM	433
	434	case OPTION_VLE_RELOC_FIXUP:
	435	params.vle_reloc_fixup = 1;
	436	break;
f9e6bfa8 AM	437	'
f9e6bfa8 AM	438
c9a2f333	439	# Put these extra ppc32elf routines in ld_${EMULATION_NAME}_emulation
f9e6bfa8	440	#
5446cbdf	441	LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_after_open_output
db434ba0	442	if test -z "$VXWORKS_BASE_EM_FILE" ; then
5c3261b0	443	LDEMUL_AFTER_CHECK_RELOCS=ppc_after_check_relocs
db434ba0	444	fi
f9e6bfa8	445	LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
b4ab4364	446	LDEMUL_FINISH=ppc_finish