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 static bfd_arm_vfp11_fix vfp11_denorm_fix = BFD_ARM_VFP11_FIX_DEFAULT;
  39 static int no_enum_size_warning = 0;
  40
  41 static void
  42 gld${EMULATION_NAME}_before_parse (void)
  43 {
  44 #ifndef TARGET_                 /* I.e., if not generic.  */
  45   ldfile_set_output_arch ("`echo ${ARCH}`", bfd_arch_unknown);
  46 #endif /* not TARGET_ */
  47   config.dynamic_link = ${DYNAMIC_LINK-TRUE};
  48   config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
  49 }
  50
  51 static void
  52 arm_elf_after_open (void)
  53 {
  54   if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
  55     {
  56       /* The arm backend needs special fields in the output hash structure.
  57          These will only be created if the output format is an arm format,
  58          hence we do not support linking and changing output formats at the
  59          same time.  Use a link followed by objcopy to change output formats.  */
  60       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
  61       return;
  62     }
  63
  64   {
  65     LANG_FOR_EACH_INPUT_STATEMENT (is)
  66       {
  67         bfd_elf32_arm_add_glue_sections_to_bfd (is->the_bfd, & link_info);
  68       }
  69   }
  70
  71   /* Call the standard elf routine.  */
  72   gld${EMULATION_NAME}_after_open ();
  73 }
  74
  75 static void
  76 arm_elf_set_bfd_for_interworking (lang_statement_union_type *statement)
  77 {
  78   if (statement->header.type == lang_input_section_enum)
  79     {
  80       asection *i = statement->input_section.section;
  81
  82       if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
  83           && (i->flags & SEC_EXCLUDE) == 0)
  84         {
  85           asection *output_section = i->output_section;
  86
  87           ASSERT (output_section->owner == output_bfd);
  88
  89           /* Don't attach the interworking stubs to a dynamic object, to
  90              an empty section, etc.  */
  91           if ((output_section->flags & SEC_HAS_CONTENTS) != 0
  92               && (i->flags & SEC_NEVER_LOAD) == 0
  93               && ! (i->owner->flags & DYNAMIC)
  94               && ! i->owner->output_has_begun)
  95             {
  96               bfd_for_interwork = i->owner;
  97               bfd_for_interwork->output_has_begun = TRUE;
  98             }
  99         }
 100     }
 101 }
 102
 103 static void
 104 arm_elf_before_allocation (void)
 105 {
 106   bfd *tem;
 107
 108   if (link_info.input_bfds != NULL)
 109     {
 110       /* The interworking bfd must be the last one in the link.  */
 111       bfd_for_interwork = NULL;
 112       for (tem = link_info.input_bfds; tem != NULL; tem = tem->link_next)
 113         tem->output_has_begun = FALSE;
 114
 115       lang_for_each_statement (arm_elf_set_bfd_for_interworking);
 116       for (tem = link_info.input_bfds; tem != NULL; tem = tem->link_next)
 117         tem->output_has_begun = FALSE;
 118
 119       /* If bfd_for_interwork is NULL, then there are no loadable sections
 120          with real contents to be linked, so we are not going to have to
 121          create any interworking stubs, so it is OK not to call
 122          bfd_elf32_arm_get_bfd_for_interworking.  */
 123       if (bfd_for_interwork != NULL)
 124         bfd_elf32_arm_get_bfd_for_interworking (bfd_for_interwork, &link_info);
 125     }
 126
 127   bfd_elf32_arm_set_byteswap_code (&link_info, byteswap_code);
 128
 129   /* Choose type of VFP11 erratum fix, or warn if specified fix is unnecessary
 130      due to architecture version.  */
 131   bfd_elf32_arm_set_vfp11_fix (output_bfd, &link_info);
 132
 133   /* We should be able to set the size of the interworking stub section.  We
 134      can't do it until later if we have dynamic sections, though.  */
 135   if (! elf_hash_table (&link_info)->dynamic_sections_created)
 136     {
 137       /* Here we rummage through the found bfds to collect glue information.  */
 138       LANG_FOR_EACH_INPUT_STATEMENT (is)
 139         {
 140           /* Initialise mapping tables for code/data.  */
 141           bfd_elf32_arm_init_maps (is->the_bfd);
 142
 143           if (!bfd_elf32_arm_process_before_allocation (is->the_bfd,
 144                                                         &link_info)
 145               || !bfd_elf32_arm_vfp11_erratum_scan (is->the_bfd, &link_info))
 146             /* xgettext:c-format */
 147             einfo (_("Errors encountered processing file %s"), is->filename);
 148         }
 149     }
 150
 151   /* Call the standard elf routine.  */
 152   gld${EMULATION_NAME}_before_allocation ();
 153
 154   /* We have seen it all. Allocate it, and carry on.  */
 155   bfd_elf32_arm_allocate_interworking_sections (& link_info);
 156 }
 157
 158 static void
 159 arm_elf_after_allocation (void)
 160 {
 161   /* Call the standard elf routine.  */
 162   after_allocation_default ();
 163
 164   {
 165     LANG_FOR_EACH_INPUT_STATEMENT (is)
 166       {
 167         /* Figure out where VFP11 erratum veneers (and the labels returning
 168            from same) have been placed.  */
 169         bfd_elf32_arm_vfp11_fix_veneer_locations (is->the_bfd, &link_info);
 170       }
 171   }
 172 }
 173
 174 static void
 175 arm_elf_finish (void)
 176 {
 177   struct bfd_link_hash_entry * h;
 178
 179   /* Call the elf32.em routine.  */
 180   gld${EMULATION_NAME}_finish ();
 181
 182   if (thumb_entry_symbol)
 183     {
 184       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
 185                                 FALSE, FALSE, TRUE);
 186     }
 187   else
 188     {
 189       struct elf_link_hash_entry * eh;
 190
 191       if (!entry_symbol.name)
 192         return;
 193
 194       h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
 195                                 FALSE, FALSE, TRUE);
 196       eh = (struct elf_link_hash_entry *)h;
 197       if (!h || ELF_ST_TYPE(eh->type) != STT_ARM_TFUNC)
 198         return;
 199     }
 200
 201
 202   if (h != (struct bfd_link_hash_entry *) NULL
 203       && (h->type == bfd_link_hash_defined
 204           || h->type == bfd_link_hash_defweak)
 205       && h->u.def.section->output_section != NULL)
 206     {
 207       static char buffer[32];
 208       bfd_vma val;
 209
 210       /* Special procesing is required for a Thumb entry symbol.  The
 211          bottom bit of its address must be set.  */
 212       val = (h->u.def.value
 213              + bfd_get_section_vma (output_bfd,
 214                                     h->u.def.section->output_section)
 215              + h->u.def.section->output_offset);
 216
 217       val |= 1;
 218
 219       /* Now convert this value into a string and store it in entry_symbol
 220          where the lang_finish() function will pick it up.  */
 221       buffer[0] = '0';
 222       buffer[1] = 'x';
 223
 224       sprintf_vma (buffer + 2, val);
 225
 226       if (thumb_entry_symbol != NULL && entry_symbol.name != NULL
 227           && entry_from_cmdline)
 228         einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
 229                thumb_entry_symbol, entry_symbol.name);
 230       entry_symbol.name = buffer;
 231     }
 232   else
 233     einfo (_("%P: warning: connot find thumb start symbol %s\n"),
 234            thumb_entry_symbol);
 235 }
 236
 237 /* This is a convenient point to tell BFD about target specific flags.
 238    After the output has been created, but before inputs are read.  */
 239 static void
 240 arm_elf_create_output_section_statements (void)
 241 {
 242   bfd_elf32_arm_set_target_relocs (output_bfd, &link_info, target1_is_rel,
 243                                    target2_type, fix_v4bx, use_blx,
 244                                    vfp11_denorm_fix, no_enum_size_warning);
 245 }
 246
 247 EOF
 248
 249 # Define some shell vars to insert bits of code into the standard elf
 250 # parse_args and list_options functions.
 251 #
 252 PARSE_AND_LIST_PROLOGUE='
 253 #define OPTION_THUMB_ENTRY              301
 254 #define OPTION_BE8                      302
 255 #define OPTION_TARGET1_REL              303
 256 #define OPTION_TARGET1_ABS              304
 257 #define OPTION_TARGET2                  305
 258 #define OPTION_FIX_V4BX                 306
 259 #define OPTION_USE_BLX                  307
 260 #define OPTION_VFP11_DENORM_FIX         308
 261 #define OPTION_NO_ENUM_SIZE_WARNING     309
 262 '
 263
 264 PARSE_AND_LIST_SHORTOPTS=p
 265
 266 PARSE_AND_LIST_LONGOPTS='
 267   { "no-pipeline-knowledge", no_argument, NULL, '\'p\''},
 268   { "thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
 269   { "be8", no_argument, NULL, OPTION_BE8},
 270   { "target1-rel", no_argument, NULL, OPTION_TARGET1_REL},
 271   { "target1-abs", no_argument, NULL, OPTION_TARGET1_ABS},
 272   { "target2", required_argument, NULL, OPTION_TARGET2},
 273   { "fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
 274   { "use-blx", no_argument, NULL, OPTION_USE_BLX},
 275   { "vfp11-denorm-fix", required_argument, NULL, OPTION_VFP11_DENORM_FIX},
 276   { "no-enum-size-warning", no_argument, NULL, OPTION_NO_ENUM_SIZE_WARNING},
 277 '
 278
 279 PARSE_AND_LIST_OPTIONS='
 280   fprintf (file, _("     --thumb-entry=<sym>      Set the entry point to be Thumb symbol <sym>\n"));
 281   fprintf (file, _("     --be8                    Oputput BE8 format image\n"));
 282   fprintf (file, _("     --target1=rel            Interpret R_ARM_TARGET1 as R_ARM_REL32\n"));
 283   fprintf (file, _("     --target1=abs            Interpret R_ARM_TARGET1 as R_ARM_ABS32\n"));
 284   fprintf (file, _("     --target2=<type>         Specify definition of R_ARM_TARGET2\n"));
 285   fprintf (file, _("     --fix-v4bx               Rewrite BX rn as MOV pc, rn for ARMv4\n"));
 286   fprintf (file, _("     --use-blx                Enable use of BLX instructions\n"));
 287   fprintf (file, _("     --vfp11-denorm-fix       Specify how to fix VFP11 denorm erratum\n"));
 288   fprintf (file, _("     --no-enum-size-warning   Don'\''t warn about objects with incompatible enum sizes\n"));
 289 '
 290
 291 PARSE_AND_LIST_ARGS_CASES='
 292     case '\'p\'':
 293       /* Only here for backwards compatibility.  */
 294       break;
 295
 296     case OPTION_THUMB_ENTRY:
 297       thumb_entry_symbol = optarg;
 298       break;
 299
 300     case OPTION_BE8:
 301       byteswap_code = 1;
 302       break;
 303
 304     case OPTION_TARGET1_REL:
 305       target1_is_rel = 1;
 306       break;
 307
 308     case OPTION_TARGET1_ABS:
 309       target1_is_rel = 0;
 310       break;
 311
 312     case OPTION_TARGET2:
 313       target2_type = optarg;
 314       break;
 315
 316     case OPTION_FIX_V4BX:
 317       fix_v4bx = 1;
 318       break;
 319
 320     case OPTION_USE_BLX:
 321       use_blx = 1;
 322       break;
 323
 324     case OPTION_VFP11_DENORM_FIX:
 325       if (strcmp (optarg, "none") == 0)
 326         vfp11_denorm_fix = BFD_ARM_VFP11_FIX_NONE;
 327       else if (strcmp (optarg, "scalar") == 0)
 328         vfp11_denorm_fix = BFD_ARM_VFP11_FIX_SCALAR;
 329       else if (strcmp (optarg, "vector") == 0)
 330         vfp11_denorm_fix = BFD_ARM_VFP11_FIX_VECTOR;
 331       else
 332         einfo (_("Unrecognized VFP11 fix type '\''%s'\''.\n"), optarg);
 333       break;
 334
 335     case OPTION_NO_ENUM_SIZE_WARNING:
 336       no_enum_size_warning = 1;
 337       break;
 338 '
 339
 340 # We have our own after_open and before_allocation functions, but they call
 341 # the standard routines, so give them a different name.
 342 LDEMUL_AFTER_OPEN=arm_elf_after_open
 343 LDEMUL_BEFORE_ALLOCATION=arm_elf_before_allocation
 344 LDEMUL_AFTER_ALLOCATION=arm_elf_after_allocation
 345 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=arm_elf_create_output_section_statements
 346
 347 # Replace the elf before_parse function with our own.
 348 LDEMUL_BEFORE_PARSE=gld"${EMULATION_NAME}"_before_parse
 349
 350 # Call the extra arm-elf function
 351 LDEMUL_FINISH=arm_elf_finish