ld/emultempl/armelf.em

   1 # This shell script emits a C file. -*- C -*-
   2 #   Copyright 1991, 1993, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3 #   2004, 2005
   4 #   Free Software Foundation, Inc.
   5 #
   6 # This file is part of GLD, the Gnu Linker.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  21 #
  22
  23 # This file is sourced from elf32.em, and defines extra arm-elf
  24 # specific routines.
  25 #
  26 test -z "$TARGET2_TYPE" && TARGET2_TYPE="rel"
  27 cat >>e${EMULATION_NAME}.c <<EOF
  28
  29 #include "elf/arm.h"
  30
  31 static char *thumb_entry_symbol = NULL;
  32 static bfd *bfd_for_interwork;
  33 static int byteswap_code = 0;
  34 static int target1_is_rel = 0${TARGET1_IS_REL};
  35 static char *target2_type = "${TARGET2_TYPE}";
  36 static int fix_v4bx = 0;
  37 static int use_blx = 0;
  38
  39 static void
  40 gld${EMULATION_NAME}_before_parse (void)
  41 {
  42 #ifndef TARGET_                 /* I.e., if not generic.  */
  43   ldfile_set_output_arch ("`echo ${ARCH}`", bfd_arch_unknown);
  44 #endif /* not TARGET_ */
  45   config.dynamic_link = ${DYNAMIC_LINK-TRUE};
  46   config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
  47 }
  48
  49 static void
  50 arm_elf_after_open (void)
  51 {
  52   if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
  53     {
  54       /* The arm backend needs special fields in the output hash structure.
  55          These will only be created if the output format is an arm format,
  56          hence we do not support linking and changing output formats at the
  57          same time.  Use a link followed by objcopy to change output formats.  */
  58       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
  59       return;
  60     }
  61
  62   {
  63     LANG_FOR_EACH_INPUT_STATEMENT (is)
  64       {
  65         bfd_elf32_arm_add_glue_sections_to_bfd (is->the_bfd, & link_info);
  66       }
  67   }
  68
  69   /* Call the standard elf routine.  */
  70   gld${EMULATION_NAME}_after_open ();
  71 }
  72
  73 static void
  74 arm_elf_set_bfd_for_interworking (lang_statement_union_type *statement)
  75 {
  76   if (statement->header.type == lang_input_section_enum)
  77     {
  78       asection *i = statement->input_section.section;
  79
  80       if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
  81           && (i->flags & SEC_EXCLUDE) == 0)
  82         {
  83           asection *output_section = i->output_section;
  84
  85           ASSERT (output_section->owner == output_bfd);
  86
  87           /* Don't attach the interworking stubs to a dynamic object, to
  88              an empty section, etc.  */
  89           if ((output_section->flags & SEC_HAS_CONTENTS) != 0
  90               && (i->flags & SEC_NEVER_LOAD) == 0
  91               && ! (i->owner->flags & DYNAMIC)
  92               && ! i->owner->output_has_begun)
  93             {
  94               bfd_for_interwork = i->owner;
  95               bfd_for_interwork->output_has_begun = TRUE;
  96             }
  97         }
  98     }
  99 }
 100
 101 static void
 102 arm_elf_before_allocation (void)
 103 {
 104   bfd *tem;
 105
 106   /* Call the standard elf routine.  */
 107   gld${EMULATION_NAME}_before_allocation ();
 108
 109   if (link_info.input_bfds != NULL)
 110     {
 111       /* The interworking bfd must be the last one in the link.  */
 112       bfd_for_interwork = NULL;
 113       for (tem = link_info.input_bfds; tem != NULL; tem = tem->link_next)
 114         tem->output_has_begun = FALSE;
 115
 116       lang_for_each_statement (arm_elf_set_bfd_for_interworking);
 117       for (tem = link_info.input_bfds; tem != NULL; tem = tem->link_next)
 118         tem->output_has_begun = FALSE;
 119
 120       /* If bfd_for_interwork is NULL, then there are no loadable sections
 121          with real contents to be linked, so we are not going to have to
 122          create any interworking stubs, so it is OK not to call
 123          bfd_elf32_arm_get_bfd_for_interworking.  */
 124       if (bfd_for_interwork != NULL)
 125         bfd_elf32_arm_get_bfd_for_interworking (bfd_for_interwork, &link_info);
 126     }
 127   /* We should be able to set the size of the interworking stub section.  */
 128
 129   /* Here we rummage through the found bfds to collect glue information.  */
 130   /* FIXME: should this be based on a command line option? krk@cygnus.com  */
 131   {
 132     LANG_FOR_EACH_INPUT_STATEMENT (is)
 133       {
 134         if (!bfd_elf32_arm_process_before_allocation (is->the_bfd, & link_info,
 135                                                       byteswap_code))
 136           {
 137             /* xgettext:c-format */
 138             einfo (_("Errors encountered processing file %s"), is->filename);
 139           }
 140       }
 141   }
 142
 143   /* We have seen it all. Allocate it, and carry on.  */
 144   bfd_elf32_arm_allocate_interworking_sections (& link_info);
 145 }
 146
 147 static void
 148 arm_elf_finish (void)
 149 {
 150   struct bfd_link_hash_entry * h;
 151
 152   /* Call the elf32.em routine.  */
 153   gld${EMULATION_NAME}_finish ();
 154
 155   if (thumb_entry_symbol)
 156     {
 157       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
 158                                 FALSE, FALSE, TRUE);
 159     }
 160   else
 161     {
 162       struct elf_link_hash_entry * eh;
 163
 164       if (!entry_symbol.name)
 165         return;
 166
 167       h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
 168                                 FALSE, FALSE, TRUE);
 169       eh = (struct elf_link_hash_entry *)h;
 170       if (!h || ELF_ST_TYPE(eh->type) != STT_ARM_TFUNC)
 171         return;
 172     }
 173
 174
 175   if (h != (struct bfd_link_hash_entry *) NULL
 176       && (h->type == bfd_link_hash_defined
 177           || h->type == bfd_link_hash_defweak)
 178       && h->u.def.section->output_section != NULL)
 179     {
 180       static char buffer[32];
 181       bfd_vma val;
 182
 183       /* Special procesing is required for a Thumb entry symbol.  The
 184          bottom bit of its address must be set.  */
 185       val = (h->u.def.value
 186              + bfd_get_section_vma (output_bfd,
 187                                     h->u.def.section->output_section)
 188              + h->u.def.section->output_offset);
 189
 190       val |= 1;
 191
 192       /* Now convert this value into a string and store it in entry_symbol
 193          where the lang_finish() function will pick it up.  */
 194       buffer[0] = '0';
 195       buffer[1] = 'x';
 196
 197       sprintf_vma (buffer + 2, val);
 198
 199       if (thumb_entry_symbol != NULL && entry_symbol.name != NULL
 200           && entry_from_cmdline)
 201         einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
 202                thumb_entry_symbol, entry_symbol.name);
 203       entry_symbol.name = buffer;
 204     }
 205   else
 206     einfo (_("%P: warning: connot find thumb start symbol %s\n"),
 207            thumb_entry_symbol);
 208 }
 209
 210 /* This is a convenitent point to tell BFD about target specific flags.
 211    After the output has been created, but before inputs are read.  */
 212 static void
 213 arm_elf_create_output_section_statements (void)
 214 {
 215   bfd_elf32_arm_set_target_relocs (&link_info, target1_is_rel, target2_type,
 216                                    fix_v4bx, use_blx);
 217 }
 218
 219 EOF
 220
 221 # Define some shell vars to insert bits of code into the standard elf
 222 # parse_args and list_options functions.
 223 #
 224 PARSE_AND_LIST_PROLOGUE='
 225 #define OPTION_THUMB_ENTRY              301
 226 #define OPTION_BE8                      302
 227 #define OPTION_TARGET1_REL              303
 228 #define OPTION_TARGET1_ABS              304
 229 #define OPTION_TARGET2                  305
 230 #define OPTION_FIX_V4BX                 306
 231 #define OPTION_USE_BLX                  307
 232 '
 233
 234 PARSE_AND_LIST_SHORTOPTS=p
 235
 236 PARSE_AND_LIST_LONGOPTS='
 237   { "no-pipeline-knowledge", no_argument, NULL, '\'p\''},
 238   { "thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
 239   { "be8", no_argument, NULL, OPTION_BE8},
 240   { "target1-rel", no_argument, NULL, OPTION_TARGET1_REL},
 241   { "target1-abs", no_argument, NULL, OPTION_TARGET1_ABS},
 242   { "target2", required_argument, NULL, OPTION_TARGET2},
 243   { "fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
 244   { "use-blx", no_argument, NULL, OPTION_USE_BLX},
 245 '
 246
 247 PARSE_AND_LIST_OPTIONS='
 248   fprintf (file, _("     --thumb-entry=<sym>      Set the entry point to be Thumb symbol <sym>\n"));
 249   fprintf (file, _("     --be8                    Oputput BE8 format image\n"));
 250   fprintf (file, _("     --target1=rel            Interpret R_ARM_TARGET1 as R_ARM_REL32\n"));
 251   fprintf (file, _("     --target1=abs            Interpret R_ARM_TARGET1 as R_ARM_ABS32\n"));
 252   fprintf (file, _("     --target2=<type>         Specify definition of R_ARM_TARGET2\n"));
 253   fprintf (file, _("     --fix-v4bx               Rewrite BX rn as MOV pc, rn for ARMv4\n"));
 254   fprintf (file, _("     --use-blx                Enable use of BLX instructions\n"));
 255 '
 256
 257 PARSE_AND_LIST_ARGS_CASES='
 258     case '\'p\'':
 259       /* Only here for backwards compatibility.  */
 260       break;
 261
 262     case OPTION_THUMB_ENTRY:
 263       thumb_entry_symbol = optarg;
 264       break;
 265
 266     case OPTION_BE8:
 267       byteswap_code = 1;
 268       break;
 269
 270     case OPTION_TARGET1_REL:
 271       target1_is_rel = 1;
 272       break;
 273
 274     case OPTION_TARGET1_ABS:
 275       target1_is_rel = 0;
 276       break;
 277
 278     case OPTION_TARGET2:
 279       target2_type = optarg;
 280       break;
 281
 282     case OPTION_FIX_V4BX:
 283       fix_v4bx = 1;
 284       break;
 285
 286     case OPTION_USE_BLX:
 287       use_blx = 1;
 288       break;
 289 '
 290
 291 # We have our own after_open and before_allocation functions, but they call
 292 # the standard routines, so give them a different name.
 293 LDEMUL_AFTER_OPEN=arm_elf_after_open
 294 LDEMUL_BEFORE_ALLOCATION=arm_elf_before_allocation
 295 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=arm_elf_create_output_section_statements
 296
 297 # Replace the elf before_parse function with our own.
 298 LDEMUL_BEFORE_PARSE=gld"${EMULATION_NAME}"_before_parse
 299
 300 # Call the extra arm-elf function
 301 LDEMUL_FINISH=arm_elf_finish