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   if (link_info.input_bfds != NULL)
 107     {
 108       /* The interworking bfd must be the last one in the link.  */
 109       bfd_for_interwork = NULL;
 110       for (tem = link_info.input_bfds; tem != NULL; tem = tem->link_next)
 111         tem->output_has_begun = FALSE;
 112
 113       lang_for_each_statement (arm_elf_set_bfd_for_interworking);
 114       for (tem = link_info.input_bfds; tem != NULL; tem = tem->link_next)
 115         tem->output_has_begun = FALSE;
 116
 117       /* If bfd_for_interwork is NULL, then there are no loadable sections
 118          with real contents to be linked, so we are not going to have to
 119          create any interworking stubs, so it is OK not to call
 120          bfd_elf32_arm_get_bfd_for_interworking.  */
 121       if (bfd_for_interwork != NULL)
 122         bfd_elf32_arm_get_bfd_for_interworking (bfd_for_interwork, &link_info);
 123     }
 124
 125   bfd_elf32_arm_set_byteswap_code (&link_info, byteswap_code);
 126
 127   /* We should be able to set the size of the interworking stub section.  We
 128      can't do it until later if we have dynamic sections, though.  */
 129   if (! elf_hash_table (&link_info)->dynamic_sections_created)
 130     {
 131       /* Here we rummage through the found bfds to collect glue information.  */
 132       LANG_FOR_EACH_INPUT_STATEMENT (is)
 133         {
 134           if (!bfd_elf32_arm_process_before_allocation (is->the_bfd,
 135                                                         &link_info))
 136             /* xgettext:c-format */
 137             einfo (_("Errors encountered processing file %s"), is->filename);
 138         }
 139     }
 140
 141   /* Call the standard elf routine.  */
 142   gld${EMULATION_NAME}_before_allocation ();
 143
 144   /* We have seen it all. Allocate it, and carry on.  */
 145   bfd_elf32_arm_allocate_interworking_sections (& link_info);
 146 }
 147
 148 static void
 149 arm_elf_finish (void)
 150 {
 151   struct bfd_link_hash_entry * h;
 152
 153   /* Call the elf32.em routine.  */
 154   gld${EMULATION_NAME}_finish ();
 155
 156   if (thumb_entry_symbol)
 157     {
 158       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
 159                                 FALSE, FALSE, TRUE);
 160     }
 161   else
 162     {
 163       struct elf_link_hash_entry * eh;
 164
 165       if (!entry_symbol.name)
 166         return;
 167
 168       h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
 169                                 FALSE, FALSE, TRUE);
 170       eh = (struct elf_link_hash_entry *)h;
 171       if (!h || ELF_ST_TYPE(eh->type) != STT_ARM_TFUNC)
 172         return;
 173     }
 174
 175
 176   if (h != (struct bfd_link_hash_entry *) NULL
 177       && (h->type == bfd_link_hash_defined
 178           || h->type == bfd_link_hash_defweak)
 179       && h->u.def.section->output_section != NULL)
 180     {
 181       static char buffer[32];
 182       bfd_vma val;
 183
 184       /* Special procesing is required for a Thumb entry symbol.  The
 185          bottom bit of its address must be set.  */
 186       val = (h->u.def.value
 187              + bfd_get_section_vma (output_bfd,
 188                                     h->u.def.section->output_section)
 189              + h->u.def.section->output_offset);
 190
 191       val |= 1;
 192
 193       /* Now convert this value into a string and store it in entry_symbol
 194          where the lang_finish() function will pick it up.  */
 195       buffer[0] = '0';
 196       buffer[1] = 'x';
 197
 198       sprintf_vma (buffer + 2, val);
 199
 200       if (thumb_entry_symbol != NULL && entry_symbol.name != NULL
 201           && entry_from_cmdline)
 202         einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
 203                thumb_entry_symbol, entry_symbol.name);
 204       entry_symbol.name = buffer;
 205     }
 206   else
 207     einfo (_("%P: warning: connot find thumb start symbol %s\n"),
 208            thumb_entry_symbol);
 209 }
 210
 211 /* This is a convenitent point to tell BFD about target specific flags.
 212    After the output has been created, but before inputs are read.  */
 213 static void
 214 arm_elf_create_output_section_statements (void)
 215 {
 216   bfd_elf32_arm_set_target_relocs (&link_info, target1_is_rel, target2_type,
 217                                    fix_v4bx, use_blx);
 218 }
 219
 220 EOF
 221
 222 # Define some shell vars to insert bits of code into the standard elf
 223 # parse_args and list_options functions.
 224 #
 225 PARSE_AND_LIST_PROLOGUE='
 226 #define OPTION_THUMB_ENTRY              301
 227 #define OPTION_BE8                      302
 228 #define OPTION_TARGET1_REL              303
 229 #define OPTION_TARGET1_ABS              304
 230 #define OPTION_TARGET2                  305
 231 #define OPTION_FIX_V4BX                 306
 232 #define OPTION_USE_BLX                  307
 233 '
 234
 235 PARSE_AND_LIST_SHORTOPTS=p
 236
 237 PARSE_AND_LIST_LONGOPTS='
 238   { "no-pipeline-knowledge", no_argument, NULL, '\'p\''},
 239   { "thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
 240   { "be8", no_argument, NULL, OPTION_BE8},
 241   { "target1-rel", no_argument, NULL, OPTION_TARGET1_REL},
 242   { "target1-abs", no_argument, NULL, OPTION_TARGET1_ABS},
 243   { "target2", required_argument, NULL, OPTION_TARGET2},
 244   { "fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
 245   { "use-blx", no_argument, NULL, OPTION_USE_BLX},
 246 '
 247
 248 PARSE_AND_LIST_OPTIONS='
 249   fprintf (file, _("     --thumb-entry=<sym>      Set the entry point to be Thumb symbol <sym>\n"));
 250   fprintf (file, _("     --be8                    Oputput BE8 format image\n"));
 251   fprintf (file, _("     --target1=rel            Interpret R_ARM_TARGET1 as R_ARM_REL32\n"));
 252   fprintf (file, _("     --target1=abs            Interpret R_ARM_TARGET1 as R_ARM_ABS32\n"));
 253   fprintf (file, _("     --target2=<type>         Specify definition of R_ARM_TARGET2\n"));
 254   fprintf (file, _("     --fix-v4bx               Rewrite BX rn as MOV pc, rn for ARMv4\n"));
 255   fprintf (file, _("     --use-blx                Enable use of BLX instructions\n"));
 256 '
 257
 258 PARSE_AND_LIST_ARGS_CASES='
 259     case '\'p\'':
 260       /* Only here for backwards compatibility.  */
 261       break;
 262
 263     case OPTION_THUMB_ENTRY:
 264       thumb_entry_symbol = optarg;
 265       break;
 266
 267     case OPTION_BE8:
 268       byteswap_code = 1;
 269       break;
 270
 271     case OPTION_TARGET1_REL:
 272       target1_is_rel = 1;
 273       break;
 274
 275     case OPTION_TARGET1_ABS:
 276       target1_is_rel = 0;
 277       break;
 278
 279     case OPTION_TARGET2:
 280       target2_type = optarg;
 281       break;
 282
 283     case OPTION_FIX_V4BX:
 284       fix_v4bx = 1;
 285       break;
 286
 287     case OPTION_USE_BLX:
 288       use_blx = 1;
 289       break;
 290 '
 291
 292 # We have our own after_open and before_allocation functions, but they call
 293 # the standard routines, so give them a different name.
 294 LDEMUL_AFTER_OPEN=arm_elf_after_open
 295 LDEMUL_BEFORE_ALLOCATION=arm_elf_before_allocation
 296 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=arm_elf_create_output_section_statements
 297
 298 # Replace the elf before_parse function with our own.
 299 LDEMUL_BEFORE_PARSE=gld"${EMULATION_NAME}"_before_parse
 300
 301 # Call the extra arm-elf function
 302 LDEMUL_FINISH=arm_elf_finish