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

# This shell script emits a C file. -*- C -*-
#   Copyright 2006, 2007
#   Free Software Foundation, Inc.
#
# This file is part of the GNU Binutils.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
# MA 02110-1301, USA.


# This file is sourced from elf32.em, and defines extra avr-elf specific
# routines.  It is used to generate the trampolines for the avr6 family
# of devices where one needs to address the issue that it is not possible
# to reach the whole program memory by using 16 bit pointers.

fragment <<EOF

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

/* The fake file and it's corresponding section meant to hold
   the linker stubs if needed.  */

static lang_input_statement_type *stub_file;
static asection *avr_stub_section;

/* Variables set by the command-line parameters and transfered
   to the bfd without use of global shared variables.  */

static bfd_boolean avr_no_stubs = FALSE;
static bfd_boolean avr_debug_relax = FALSE;
static bfd_boolean avr_debug_stubs = FALSE;
static bfd_boolean avr_replace_call_ret_sequences = TRUE;
static bfd_vma avr_pc_wrap_around = 0x10000000;

/* Transfers information to the bfd frontend.  */

static void
avr_elf_set_global_bfd_parameters (void)
{
  elf32_avr_setup_params (& link_info,
                          stub_file->the_bfd,
                          avr_stub_section,
                          avr_no_stubs,
                          avr_debug_stubs,
                          avr_debug_relax,
                          avr_pc_wrap_around,
                          avr_replace_call_ret_sequences);
}


/* Makes a conservative estimate of the trampoline section size that could
   be corrected later on.  */

static void
avr_elf_${EMULATION_NAME}_before_allocation (void)
{
  int ret;

  gld${EMULATION_NAME}_before_allocation ();

  /* We only need stubs for the avr6 family.  */
  if (strcmp ("${EMULATION_NAME}","avr6"))
    avr_no_stubs = TRUE;

  avr_elf_set_global_bfd_parameters ();

  /* If generating a relocatable output file, then
     we don't  have to generate the trampolines.  */
  if (link_info.relocatable)
    avr_no_stubs = TRUE;

  if (avr_no_stubs)
    return;

  ret = elf32_avr_setup_section_lists (output_bfd, &link_info);

  if (ret < 0)
    einfo ("%X%P: can not setup the input section list: %E\n");

  if (ret <= 0)
    return;

  /* Call into the BFD backend to do the real "stub"-work.  */
  if (! elf32_avr_size_stubs (output_bfd, &link_info, TRUE))
    einfo ("%X%P: can not size stub section: %E\n");
}

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

static void
avr_elf_create_output_section_statements (void)
{
  flagword flags;

  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 stub BFD %E\n");
      return;
    }

  /* Now we add the stub section.  */

  avr_stub_section = bfd_make_section_anyway (stub_file->the_bfd,
                                              ".trampolines");
  if (avr_stub_section == 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, avr_stub_section, flags))
    goto err_ret;

  avr_stub_section->alignment_power = 1;

  ldlang_add_file (stub_file);

  return;

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

/* Re-calculates the size of the stubs so that we won't waste space.  */

static void
avr_elf_finish (void)
{
  if (!avr_no_stubs)
    {
      /* Now build the linker stubs.  */
      if (stub_file->the_bfd->sections != NULL)
       {
         /* Call again the trampoline analyzer to initialize the trampoline
            stubs with the correct symbol addresses.  Since there could have
            been relaxation, the symbol addresses that were found during
            first call may no longer be correct.  */
         if (!elf32_avr_size_stubs (output_bfd, &link_info, FALSE))
           {
             einfo ("%X%P: can not size stub section: %E\n");
             return;
           }

         if (!elf32_avr_build_stubs (&link_info))
           einfo ("%X%P: can not build stubs: %E\n");
       }
    }

  gld${EMULATION_NAME}_finish ();
}


EOF


PARSE_AND_LIST_PROLOGUE='

#define OPTION_NO_CALL_RET_REPLACEMENT 301
#define OPTION_PMEM_WRAP_AROUND        302
#define OPTION_NO_STUBS                303
#define OPTION_DEBUG_STUBS             304
#define OPTION_DEBUG_RELAX             305
'

PARSE_AND_LIST_LONGOPTS='
  { "no-call-ret-replacement", no_argument,
     NULL, OPTION_NO_CALL_RET_REPLACEMENT},
  { "pmem-wrap-around", required_argument,
    NULL, OPTION_PMEM_WRAP_AROUND},
  { "no-stubs", no_argument,
    NULL, OPTION_NO_STUBS},
  { "debug-stubs", no_argument,
    NULL, OPTION_DEBUG_STUBS},
  { "debug-relax", no_argument,
    NULL, OPTION_DEBUG_RELAX},
'

PARSE_AND_LIST_OPTIONS='
  fprintf (file, _("  --pmem-wrap-around=<val>    "
		   "Make the linker relaxation machine assume that a\n"
		   "                              "
		   "  program counter wrap-around occures at address\n"
		   "                              "
		   "  <val>.  Supported values: 8k, 16k, 32k and 64k.\n"));
  fprintf (file, _("  --no-call-ret-replacement   "
		   "The relaxation machine normally will\n"
		   "                              "
		   "  substitute two immediately following call/ret\n"
		   "                              "
		   "  instructions by a single jump instruction.\n"
		   "                              "
		   "  This option disables this optimization.\n"));
  fprintf (file, _("  --no-stubs                  "
		   "If the linker detects to attempt to access\n"
		   "                              "
		   "  an instruction beyond 128k by a reloc that\n"
		   "                              "
		   "  is limited to 128k max, it inserts a jump\n"
		   "                              "
		   "  stub. You can de-active this with this switch.\n"));
  fprintf (file, _("  --debug-stubs               "
		   "Used for debugging avr-ld.\n"));
  fprintf (file, _("  --debug-relax               "
		   "Used for debugging avr-ld.\n"));
'

PARSE_AND_LIST_ARGS_CASES='

    case OPTION_PMEM_WRAP_AROUND:
      {
        /* This variable is defined in the bfd library.  */
        if ((!strcmp (optarg,"32k"))      || (!strcmp (optarg,"32K")))
          avr_pc_wrap_around = 32768;
        else if ((!strcmp (optarg,"8k")) || (!strcmp (optarg,"8K")))
          avr_pc_wrap_around = 8192;
        else if ((!strcmp (optarg,"16k")) || (!strcmp (optarg,"16K")))
          avr_pc_wrap_around = 16384;
        else if ((!strcmp (optarg,"64k")) || (!strcmp (optarg,"64K")))
          avr_pc_wrap_around = 0x10000;
        else
          return FALSE;
      }
      break;

    case OPTION_DEBUG_STUBS:
      avr_debug_stubs = TRUE;
      break;

    case OPTION_DEBUG_RELAX:
      avr_debug_relax = TRUE;
      break;

    case OPTION_NO_STUBS:
      avr_no_stubs = TRUE;
      break;

    case OPTION_NO_CALL_RET_REPLACEMENT:
      {
        /* This variable is defined in the bfd library.  */
        avr_replace_call_ret_sequences = FALSE;
      }
      break;
'

#
# Put these extra avr-elf routines in ld_${EMULATION_NAME}_emulation
#
LDEMUL_BEFORE_ALLOCATION=avr_elf_${EMULATION_NAME}_before_allocation
LDEMUL_FINISH=avr_elf_finish
LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=avr_elf_create_output_section_statements
Commit	Line	Data
28c9d252	1	# This shell script emits a C file. -- C --
f96b4a7b	2	# Copyright 2006, 2007
28c9d252 NC	3	# Free Software Foundation, Inc.
28c9d252 NC	4	#
f96b4a7b	5	# This file is part of the GNU Binutils.
28c9d252 NC	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
f96b4a7b	9	# the Free Software Foundation; either version 3 of the License, or
28c9d252 NC	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
f96b4a7b NC	19	# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
f96b4a7b NC	20	# MA 02110-1301, USA.
28c9d252	21
f96b4a7b NC	22
	23	# This file is sourced from elf32.em, and defines extra avr-elf specific
	24	# routines. It is used to generate the trampolines for the avr6 family
	25	# of devices where one needs to address the issue that it is not possible
28c9d252 NC	26	# to reach the whole program memory by using 16 bit pointers.
28c9d252 NC	27
92b93329	28	fragment <<EOF
28c9d252 NC	29
	30	#include "elf32-avr.h"
	31	#include "ldctor.h"
	32
92b93329	33	/* The fake file and it's corresponding section meant to hold
28c9d252 NC	34	the linker stubs if needed. */
	35
	36	static lang_input_statement_type *stub_file;
	37	static asection *avr_stub_section;
	38
	39	/* Variables set by the command-line parameters and transfered
	40	to the bfd without use of global shared variables. */
	41
	42	static bfd_boolean avr_no_stubs = FALSE;
	43	static bfd_boolean avr_debug_relax = FALSE;
	44	static bfd_boolean avr_debug_stubs = FALSE;
	45	static bfd_boolean avr_replace_call_ret_sequences = TRUE;
	46	static bfd_vma avr_pc_wrap_around = 0x10000000;
	47
	48	/* Transfers information to the bfd frontend. */
	49
	50	static void
	51	avr_elf_set_global_bfd_parameters (void)
	52	{
	53	elf32_avr_setup_params (& link_info,
	54	stub_file->the_bfd,
	55	avr_stub_section,
	56	avr_no_stubs,
	57	avr_debug_stubs,
	58	avr_debug_relax,
	59	avr_pc_wrap_around,
	60	avr_replace_call_ret_sequences);
	61	}
	62
	63
	64	/* Makes a conservative estimate of the trampoline section size that could
	65	be corrected later on. */
	66
	67	static void
	68	avr_elf_${EMULATION_NAME}_before_allocation (void)
	69	{
	70	int ret;
	71
	72	gld${EMULATION_NAME}_before_allocation ();
	73
	74	/* We only need stubs for the avr6 family. */
	75	if (strcmp ("${EMULATION_NAME}","avr6"))
	76	avr_no_stubs = TRUE;
	77
	78	avr_elf_set_global_bfd_parameters ();
	79
	80	/* If generating a relocatable output file, then
	81	we don't have to generate the trampolines. */
	82	if (link_info.relocatable)
	83	avr_no_stubs = TRUE;
	84
	85	if (avr_no_stubs)
	86	return;
	87
	88	ret = elf32_avr_setup_section_lists (output_bfd, &link_info);
	89
	90	if (ret < 0)
	91	einfo ("%X%P: can not setup the input section list: %E\n");
	92
	93	if (ret <= 0)
	94	return;
	95
	96	/* Call into the BFD backend to do the real "stub"-work. */
	97	if (! elf32_avr_size_stubs (output_bfd, &link_info, TRUE))
98	einfo ("%X%P: can not size stub section: %E\n");
99	}
100
101	/* This is called before the input files are opened. We create a new
102	fake input file to hold the stub section and generate the section itself. */
103
104	static void
105	avr_elf_create_output_section_statements (void)
106	{
107	flagword flags;
108
109	stub_file = lang_add_input_file ("linker stubs",
110	lang_input_file_is_fake_enum,
111	NULL);
112
113	stub_file->the_bfd = bfd_create ("linker stubs", output_bfd);
114	if (stub_file->the_bfd == NULL
115	\|\| !bfd_set_arch_mach (stub_file->the_bfd,
116	bfd_get_arch (output_bfd),
117	bfd_get_mach (output_bfd)))
118	{
119	einfo ("%X%P: can not create stub BFD %E\n");
120	return;
121	}
122
123	/* Now we add the stub section. */
124
125	avr_stub_section = bfd_make_section_anyway (stub_file->the_bfd,
126	".trampolines");
127	if (avr_stub_section == NULL)
128	goto err_ret;
92b93329	129
28c9d252 NC	130	flags = (SEC_ALLOC \| SEC_LOAD \| SEC_READONLY \| SEC_CODE
	131	\| SEC_HAS_CONTENTS \| SEC_RELOC \| SEC_IN_MEMORY \| SEC_KEEP);
	132	if (!bfd_set_section_flags (stub_file->the_bfd, avr_stub_section, flags))
	133	goto err_ret;
	134
	135	avr_stub_section->alignment_power = 1;
92b93329	136
28c9d252 NC	137	ldlang_add_file (stub_file);
	138
	139	return;
	140
	141	err_ret:
	142	einfo ("%X%P: can not make stub section: %E\n");
	143	return;
	144	}
	145
	146	/* Re-calculates the size of the stubs so that we won't waste space. */
	147
	148	static void
	149	avr_elf_finish (void)
92b93329	150	{
28c9d252 NC	151	if (!avr_no_stubs)
	152	{
	153	/* Now build the linker stubs. */
	154	if (stub_file->the_bfd->sections != NULL)
	155	{
	156	/* Call again the trampoline analyzer to initialize the trampoline
	157	stubs with the correct symbol addresses. Since there could have
	158	been relaxation, the symbol addresses that were found during
	159	first call may no longer be correct. */
	160	if (!elf32_avr_size_stubs (output_bfd, &link_info, FALSE))
	161	{
	162	einfo ("%X%P: can not size stub section: %E\n");
	163	return;
	164	}
	165
	166	if (!elf32_avr_build_stubs (&link_info))
	167	einfo ("%X%P: can not build stubs: %E\n");
	168	}
	169	}
	170
	171	gld${EMULATION_NAME}_finish ();
	172	}
	173
	174
	175	EOF
	176
	177
	178	PARSE_AND_LIST_PROLOGUE='
	179
	180	#define OPTION_NO_CALL_RET_REPLACEMENT 301
	181	#define OPTION_PMEM_WRAP_AROUND 302
	182	#define OPTION_NO_STUBS 303
	183	#define OPTION_DEBUG_STUBS 304
	184	#define OPTION_DEBUG_RELAX 305
	185	'
	186
	187	PARSE_AND_LIST_LONGOPTS='
92b93329	188	{ "no-call-ret-replacement", no_argument,
28c9d252	189	NULL, OPTION_NO_CALL_RET_REPLACEMENT},
92b93329	190	{ "pmem-wrap-around", required_argument,
28c9d252	191	NULL, OPTION_PMEM_WRAP_AROUND},
92b93329	192	{ "no-stubs", no_argument,
28c9d252	193	NULL, OPTION_NO_STUBS},
92b93329	194	{ "debug-stubs", no_argument,
28c9d252	195	NULL, OPTION_DEBUG_STUBS},
92b93329	196	{ "debug-relax", no_argument,
28c9d252 NC	197	NULL, OPTION_DEBUG_RELAX},
	198	'
	199
	200	PARSE_AND_LIST_OPTIONS='
442996ee AM	201	fprintf (file, _(" --pmem-wrap-around=<val> "
	202	"Make the linker relaxation machine assume that a\n"
	203	" "
	204	" program counter wrap-around occures at address\n"
	205	" "
	206	" <val>. Supported values: 8k, 16k, 32k and 64k.\n"));
	207	fprintf (file, _(" --no-call-ret-replacement "
	208	"The relaxation machine normally will\n"
	209	" "
	210	" substitute two immediately following call/ret\n"
	211	" "
	212	" instructions by a single jump instruction.\n"
	213	" "
	214	" This option disables this optimization.\n"));
	215	fprintf (file, _(" --no-stubs "
	216	"If the linker detects to attempt to access\n"
	217	" "
	218	" an instruction beyond 128k by a reloc that\n"
	219	" "
	220	" is limited to 128k max, it inserts a jump\n"
	221	" "
	222	" stub. You can de-active this with this switch.\n"));
	223	fprintf (file, _(" --debug-stubs "
	224	"Used for debugging avr-ld.\n"));
	225	fprintf (file, _(" --debug-relax "
	226	"Used for debugging avr-ld.\n"));
28c9d252 NC	227	'
	228
	229	PARSE_AND_LIST_ARGS_CASES='
	230
	231	case OPTION_PMEM_WRAP_AROUND:
92b93329	232	{
28c9d252 NC	233	/* This variable is defined in the bfd library. */
	234	if ((!strcmp (optarg,"32k")) \|\| (!strcmp (optarg,"32K")))
	235	avr_pc_wrap_around = 32768;
2a69000b DC	236	else if ((!strcmp (optarg,"8k")) \|\| (!strcmp (optarg,"8K")))
2a69000b DC	237	avr_pc_wrap_around = 8192;
28c9d252 NC	238	else if ((!strcmp (optarg,"16k")) \|\| (!strcmp (optarg,"16K")))
	239	avr_pc_wrap_around = 16384;
	240	else if ((!strcmp (optarg,"64k")) \|\| (!strcmp (optarg,"64K")))
	241	avr_pc_wrap_around = 0x10000;
	242	else
	243	return FALSE;
	244	}
	245	break;
	246
	247	case OPTION_DEBUG_STUBS:
	248	avr_debug_stubs = TRUE;
	249	break;
	250
	251	case OPTION_DEBUG_RELAX:
	252	avr_debug_relax = TRUE;
	253	break;
	254
	255	case OPTION_NO_STUBS:
	256	avr_no_stubs = TRUE;
	257	break;
	258
	259	case OPTION_NO_CALL_RET_REPLACEMENT:
	260	{
	261	/* This variable is defined in the bfd library. */
	262	avr_replace_call_ret_sequences = FALSE;
	263	}
	264	break;
	265	'
	266
	267	#
	268	# Put these extra avr-elf routines in ld_${EMULATION_NAME}_emulation
	269	#
	270	LDEMUL_BEFORE_ALLOCATION=avr_elf_${EMULATION_NAME}_before_allocation
	271	LDEMUL_FINISH=avr_elf_finish
	272	LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=avr_elf_create_output_section_statements