Home | History | Annotate | Download | only in bfd
      1 /* Renesas / SuperH specific support for Symbian 32-bit ELF files
      2    Copyright (C) 2004-2014 Free Software Foundation, Inc.
      3    Contributed by Red Hat
      4 
      5    This file is part of BFD, the Binary File Descriptor library.
      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
      9    the Free Software Foundation; either version 3 of the License, or
     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
     19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     20    MA 02110-1301, USA.  */
     21 
     22 
     23 /* Stop elf32-sh.c from defining any target vectors.  */
     24 #define SH_TARGET_ALREADY_DEFINED
     25 #define sh_find_elf_flags           sh_symbian_find_elf_flags
     26 #define sh_elf_get_flags_from_mach  sh_symbian_elf_get_flags_from_mach
     27 #include "elf32-sh.c"
     28 
     29 
     30 //#define SYMBIAN_DEBUG 1
     31 #define SYMBIAN_DEBUG 0
     32 
     33 #define DIRECTIVE_HEADER	"#<SYMEDIT>#\n"
     34 #define DIRECTIVE_IMPORT	"IMPORT "
     35 #define DIRECTIVE_EXPORT	"EXPORT "
     36 #define DIRECTIVE_AS		"AS "
     37 
     38 /* Macro to advance 's' until either it reaches 'e' or the
     39    character pointed to by 's' is equal to 'c'.  If 'e' is
     40    reached and SYMBIAN_DEBUG is enabled then the error message 'm'
     41    is displayed.  */
     42 #define SKIP_UNTIL(s,e,c,m)					\
     43   do								\
     44     {								\
     45       while (s < e && *s != c)					\
     46 	++ s;							\
     47       if (s >= e)						\
     48 	{							\
     49           if (SYMBIAN_DEBUG)					\
     50 	    fprintf (stderr, "Corrupt directive: %s\n", m);	\
     51 	  result = FALSE;					\
     52 	}							\
     53     }								\
     54   while (0);							\
     55   if (!result)							\
     56      break;
     57 
     58 /* Like SKIP_UNTIL except there are two terminator characters
     59    c1 and c2.  */
     60 #define SKIP_UNTIL2(s,e,c1,c2,m)				\
     61   do								\
     62     {								\
     63       while (s < e && *s != c1 && *s != c2)			\
     64 	++ s;							\
     65       if (s >= e)						\
     66 	{							\
     67           if (SYMBIAN_DEBUG)					\
     68 	    fprintf (stderr, "Corrupt directive: %s\n", m);	\
     69 	  result = FALSE;					\
     70 	}							\
     71     }								\
     72   while (0);							\
     73   if (!result)							\
     74      break;
     75 
     76 /* Macro to advance 's' until either it reaches 'e' or the
     77    character pointed to by 's' is not equal to 'c'.  If 'e'
     78    is reached and SYMBIAN_DEBUG is enabled then the error message
     79    'm' is displayed.  */
     80 #define SKIP_WHILE(s,e,c,m)					\
     81   do								\
     82     {								\
     83       while (s < e && *s == c)					\
     84 	++ s;							\
     85       if (s >= e)						\
     86 	{							\
     87           if (SYMBIAN_DEBUG)					\
     88 	    fprintf (stderr, "Corrupt directive: %s\n", m);	\
     89 	  result = FALSE;					\
     90 	}							\
     91     }								\
     92   while (0);							\
     93   if (!result)							\
     94      break;
     95 
     96 
     97 typedef struct symbol_rename
     98 {
     99   struct symbol_rename *       next;
    100   char *                       current_name;
    101   char *                       new_name;
    102   struct elf_link_hash_entry * current_hash;
    103   unsigned long                new_symndx;
    104 }
    105 symbol_rename;
    106 
    107 static symbol_rename * rename_list = NULL;
    108 
    109 /* Accumulate a list of symbols to be renamed.  */
    110 
    111 static bfd_boolean
    112 sh_symbian_import_as (struct bfd_link_info *info, bfd * abfd,
    113 		      char * current_name, char * new_name)
    114 {
    115   struct elf_link_hash_entry * new_hash;
    116   symbol_rename * node;
    117 
    118   if (SYMBIAN_DEBUG)
    119     fprintf (stderr, "IMPORT '%s' AS '%s'\n", current_name, new_name);
    120 
    121   for (node = rename_list; node; node = node->next)
    122     if (strcmp (node->current_name, current_name) == 0)
    123       {
    124 	if (strcmp (node->new_name, new_name) == 0)
    125 	  /* Already added to rename list.  */
    126 	  return TRUE;
    127 
    128 	bfd_set_error (bfd_error_invalid_operation);
    129 	_bfd_error_handler (_("%B: IMPORT AS directive for %s conceals previous IMPORT AS"),
    130 			    abfd, current_name);
    131 	return FALSE;
    132       }
    133 
    134   if ((node = bfd_malloc (sizeof * node)) == NULL)
    135     {
    136       if (SYMBIAN_DEBUG)
    137 	fprintf (stderr, "IMPORT AS: No mem for new rename node\n");
    138       return FALSE;
    139     }
    140 
    141   if ((node->current_name = bfd_malloc (strlen (current_name) + 1)) == NULL)
    142     {
    143       if (SYMBIAN_DEBUG)
    144 	fprintf (stderr, "IMPORT AS: No mem for current name field in rename node\n");
    145       free (node);
    146       return FALSE;
    147     }
    148   else
    149     strcpy (node->current_name, current_name);
    150 
    151   if ((node->new_name = bfd_malloc (strlen (new_name) + 1)) == NULL)
    152     {
    153       if (SYMBIAN_DEBUG)
    154 	fprintf (stderr, "IMPORT AS: No mem for new name field in rename node\n");
    155       free (node->current_name);
    156       free (node);
    157       return FALSE;
    158     }
    159   else
    160     strcpy (node->new_name, new_name);
    161 
    162   node->next = rename_list;
    163   node->current_hash = NULL;
    164   node->new_symndx = 0;
    165   rename_list = node;
    166 
    167   new_hash = elf_link_hash_lookup (elf_hash_table (info), node->new_name, TRUE, FALSE, TRUE);
    168   bfd_elf_link_record_dynamic_symbol (info, new_hash);
    169   if (new_hash->root.type == bfd_link_hash_new)
    170     new_hash->root.type = bfd_link_hash_undefined;
    171 
    172   return TRUE;
    173 }
    174 
    175 
    176 static bfd_boolean
    177 sh_symbian_import (bfd * abfd ATTRIBUTE_UNUSED, char * name)
    178 {
    179   if (SYMBIAN_DEBUG)
    180     fprintf (stderr, "IMPORT '%s'\n", name);
    181 
    182   /* XXX: Generate an import somehow ?  */
    183 
    184   return TRUE;
    185 }
    186 
    187 static bfd_boolean
    188 sh_symbian_export (bfd * abfd ATTRIBUTE_UNUSED, char * name)
    189 {
    190   if (SYMBIAN_DEBUG)
    191     fprintf (stderr, "EXPORT '%s'\n", name);
    192 
    193   /* XXX: Generate an export somehow ?  */
    194 
    195   return TRUE;
    196 }
    197 
    198 /* Process any magic embedded commands in the .directive. section.
    199    Returns TRUE upon sucecss, but if it fails it sets bfd_error and
    200    returns FALSE.  */
    201 
    202 static bfd_boolean
    203 sh_symbian_process_embedded_commands (struct bfd_link_info *info, bfd * abfd,
    204 				      asection * sec, bfd_byte * contents)
    205 {
    206   char *s;
    207   char *e;
    208   bfd_boolean result = TRUE;
    209   bfd_size_type sz = sec->rawsize ? sec->rawsize : sec->size;
    210 
    211   for (s = (char *) contents, e = s + sz; s < e;)
    212     {
    213       char * directive = s;
    214 
    215       switch (*s)
    216 	{
    217 	  /* I want to use "case DIRECTIVE_HEADER [0]:" here but gcc won't let me :-(  */
    218 	case '#':
    219 	  if (strcmp (s, DIRECTIVE_HEADER))
    220 	    result = FALSE;
    221 	  else
    222 	    /* Just ignore the header.
    223 	       XXX: Strictly speaking we ought to check that the header
    224 	       is present and that it is the first thing in the file.  */
    225 	    s += strlen (DIRECTIVE_HEADER) + 1;
    226 	  break;
    227 
    228 	case 'I':
    229 	  if (! CONST_STRNEQ (s, DIRECTIVE_IMPORT))
    230 	    result = FALSE;
    231 	  else
    232 	    {
    233 	      char * new_name;
    234 	      char * new_name_end;
    235 	      char   name_end_char;
    236 
    237 	      /* Skip the IMPORT directive.  */
    238 	      s += strlen (DIRECTIVE_IMPORT);
    239 
    240 	      new_name = s;
    241 	      /* Find the end of the new name.  */
    242 	      while (s < e && *s != ' ' && *s != '\n')
    243 		++ s;
    244 	      if (s >= e)
    245 		{
    246 		  /* We have reached the end of the .directive section
    247 		     without encountering a string terminator.  This is
    248 		     allowed for IMPORT directives.  */
    249 		  new_name_end   = e - 1;
    250 		  name_end_char  = * new_name_end;
    251 		  * new_name_end = 0;
    252 		  result = sh_symbian_import (abfd, new_name);
    253 		  * new_name_end = name_end_char;
    254 		  break;
    255 		}
    256 
    257 	      /* Remember where the name ends.  */
    258 	      new_name_end = s;
    259 	      /* Skip any whitespace before the 'AS'.  */
    260 	      SKIP_WHILE (s, e, ' ', "IMPORT: Name just followed by spaces");
    261 	      /* Terminate the new name.  (Do this after skiping...)  */
    262 	      name_end_char = * new_name_end;
    263 	      * new_name_end = 0;
    264 
    265 	      /* Check to see if 'AS '... is present.  If so we have an
    266 		 IMPORT AS directive, otherwise we have an IMPORT directive.  */
    267 	      if (! CONST_STRNEQ (s, DIRECTIVE_AS))
    268 		{
    269 		  /* Skip the new-line at the end of the name.  */
    270 		  if (SYMBIAN_DEBUG && name_end_char != '\n')
    271 		    fprintf (stderr, "IMPORT: No newline at end of directive\n");
    272 		  else
    273 		    s ++;
    274 
    275 		  result = sh_symbian_import (abfd, new_name);
    276 
    277 		  /* Skip past the NUL character.  */
    278 		  if (* s ++ != 0)
    279 		    {
    280 		      if (SYMBIAN_DEBUG)
    281 			fprintf (stderr, "IMPORT: No NUL at end of directive\n");
    282 		    }
    283 		}
    284 	      else
    285 		{
    286 		  char * current_name;
    287 		  char * current_name_end;
    288 		  char   current_name_end_char;
    289 
    290 		  /* Skip the 'AS '.  */
    291 		  s += strlen (DIRECTIVE_AS);
    292 		  /* Skip any white space after the 'AS '.  */
    293 		  SKIP_WHILE (s, e, ' ', "IMPORT AS: Nothing after AS");
    294 		  current_name = s;
    295 		  /* Find the end of the current name.  */
    296 		  SKIP_UNTIL2 (s, e, ' ', '\n', "IMPORT AS: No newline at the end of the current name");
    297 		  /* Skip (backwards) over spaces at the end of the current name.  */
    298 		  current_name_end = s;
    299 		  current_name_end_char = * current_name_end;
    300 
    301 		  SKIP_WHILE (s, e, ' ', "IMPORT AS: Current name just followed by spaces");
    302 		  /* Skip past the newline character.  */
    303 		  if (* s ++ != '\n')
    304 		    if (SYMBIAN_DEBUG)
    305 		      fprintf (stderr, "IMPORT AS: No newline at end of directive\n");
    306 
    307 		  /* Terminate the current name after having performed the skips.  */
    308 		  * current_name_end = 0;
    309 
    310 		  result = sh_symbian_import_as (info, abfd, current_name, new_name);
    311 
    312 		  /* The next character should be a NUL.  */
    313 		  if (* s != 0)
    314 		    {
    315 		      if (SYMBIAN_DEBUG)
    316 			fprintf (stderr, "IMPORT AS: Junk at end of directive\n");
    317 		      result = FALSE;
    318 		    }
    319 		  s ++;
    320 
    321 		  * current_name_end = current_name_end_char;
    322 		}
    323 
    324 	      /* Restore the characters we overwrote, since
    325 		 the .directive section will be emitted.  */
    326 	      * new_name_end = name_end_char;
    327 	    }
    328 	  break;
    329 
    330 	case 'E':
    331 	  if (! CONST_STRNEQ (s, DIRECTIVE_EXPORT))
    332 	    result = FALSE;
    333 	  else
    334 	    {
    335 	      char * name;
    336 	      char * name_end;
    337 	      char   name_end_char;
    338 
    339 	      /* Skip the directive.  */
    340 	      s += strlen (DIRECTIVE_EXPORT);
    341 	      name = s;
    342 	      /* Find the end of the name to be exported.  */
    343 	      SKIP_UNTIL (s, e, '\n', "EXPORT: no newline at end of directive");
    344 	      /* Skip (backwards) over spaces at end of exported name.  */
    345 	      for (name_end = s; name_end[-1] == ' '; name_end --)
    346 		;
    347 	      /* name_end now points at the first character after the
    348 		 end of the exported name, so we can termiante it  */
    349 	      name_end_char = * name_end;
    350 	      * name_end = 0;
    351 	      /* Skip passed the newline character.  */
    352 	      s ++;
    353 
    354 	      result = sh_symbian_export (abfd, name);
    355 
    356 	      /* The next character should be a NUL.  */
    357 	      if (* s != 0)
    358 		{
    359 		  if (SYMBIAN_DEBUG)
    360 		    fprintf (stderr, "EXPORT: Junk at end of directive\n");
    361 		  result = FALSE;
    362 		}
    363 	      s++;
    364 
    365 	      /* Restore the character we deleted.  */
    366 	      * name_end = name_end_char;
    367 	    }
    368 	  break;
    369 
    370 	default:
    371 	  result = FALSE;
    372 	  break;
    373 	}
    374 
    375       if (! result)
    376 	{
    377 	  if (SYMBIAN_DEBUG)
    378 	    fprintf (stderr, "offset into .directive section: %ld\n",
    379 		     (long) (directive - (char *) contents));
    380 
    381 	  bfd_set_error (bfd_error_invalid_operation);
    382 	  _bfd_error_handler (_("%B: Unrecognised .directive command: %s"),
    383 			      abfd, directive);
    384 	  break;
    385 	}
    386     }
    387 
    388   return result;
    389 }
    390 
    391 
    392 /* Scan a bfd for a .directive section, and if found process it.
    393    Returns TRUE upon success, FALSE otherwise.  */
    394 
    395 static bfd_boolean
    396 sh_symbian_process_directives (bfd *abfd, struct bfd_link_info *info)
    397 {
    398   bfd_boolean result = FALSE;
    399   bfd_byte *  contents;
    400   asection *  sec = bfd_get_section_by_name (abfd, ".directive");
    401   bfd_size_type sz;
    402 
    403   if (!sec)
    404     return TRUE;
    405 
    406   sz = sec->rawsize ? sec->rawsize : sec->size;
    407   contents = bfd_malloc (sz);
    408 
    409   if (!contents)
    410     bfd_set_error (bfd_error_no_memory);
    411   else
    412     {
    413       if (bfd_get_section_contents (abfd, sec, contents, 0, sz))
    414 	result = sh_symbian_process_embedded_commands (info, abfd, sec, contents);
    415       free (contents);
    416     }
    417 
    418   return result;
    419 }
    420 
    421 /* Intercept the normal sh_relocate_section() function
    422    and magle the relocs to allow for symbol renaming.  */
    423 
    424 static bfd_boolean
    425 sh_symbian_relocate_section (bfd *                  output_bfd,
    426 			     struct bfd_link_info * info,
    427 			     bfd *                  input_bfd,
    428 			     asection *             input_section,
    429 			     bfd_byte *             contents,
    430 			     Elf_Internal_Rela *    relocs,
    431 			     Elf_Internal_Sym *     local_syms,
    432 			     asection **            local_sections)
    433 {
    434   /* When performing a final link we implement the IMPORT AS directives.  */
    435   if (!info->relocatable)
    436     {
    437       Elf_Internal_Rela *            rel;
    438       Elf_Internal_Rela *            relend;
    439       Elf_Internal_Shdr *            symtab_hdr;
    440       struct elf_link_hash_entry **  sym_hashes;
    441       struct elf_link_hash_entry **  sym_hashes_end;
    442       struct elf_link_hash_table *   hash_table;
    443       symbol_rename *                ptr;
    444       bfd_size_type                  num_global_syms;
    445       unsigned long		     num_local_syms;
    446 
    447       BFD_ASSERT (! elf_bad_symtab (input_bfd));
    448 
    449       symtab_hdr       = & elf_tdata (input_bfd)->symtab_hdr;
    450       hash_table       = elf_hash_table (info);
    451       num_local_syms   = symtab_hdr->sh_info;
    452       num_global_syms  = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
    453       num_global_syms -= num_local_syms;
    454       sym_hashes       = elf_sym_hashes (input_bfd);
    455       sym_hashes_end   = sym_hashes + num_global_syms;
    456 
    457       /* First scan the rename table, caching the hash entry and the new index.  */
    458       for (ptr = rename_list; ptr; ptr = ptr->next)
    459 	{
    460 	  struct elf_link_hash_entry *   new_hash;
    461 	  struct elf_link_hash_entry **  h;
    462 
    463 	  ptr->current_hash = elf_link_hash_lookup (hash_table, ptr->current_name, FALSE, FALSE, TRUE);
    464 
    465 	  if (ptr->current_hash == NULL)
    466 	    {
    467 	      if (SYMBIAN_DEBUG)
    468 		fprintf (stderr, "IMPORT AS: current symbol '%s' does not exist\n", ptr->current_name);
    469 	      continue;
    470 	    }
    471 
    472 	  new_hash = elf_link_hash_lookup (hash_table, ptr->new_name,
    473 					   FALSE, FALSE, TRUE);
    474 	  /* If we could not find the symbol then it is a new, undefined symbol.
    475 	     Symbian want this behaviour - ie they want to be able to rename the
    476 	     reference in a reloc from one undefined symbol to another, new and
    477 	     undefined symbol.  So we create that symbol here.  */
    478 	  if (new_hash == NULL)
    479 	    {
    480 	      struct bfd_link_hash_entry *bh = NULL;
    481 	      bfd_boolean collect = get_elf_backend_data (input_bfd)->collect;
    482 	      if (_bfd_generic_link_add_one_symbol (info, input_bfd,
    483 						    ptr->new_name, BSF_GLOBAL,
    484 						    bfd_und_section_ptr, 0,
    485 						    NULL, FALSE, collect,
    486 						    &bh))
    487 		{
    488 		  new_hash = (struct elf_link_hash_entry *) bh;
    489 		  new_hash->type = STT_FUNC;
    490 		  new_hash->non_elf = 0;
    491 
    492 		  if (SYMBIAN_DEBUG)
    493 		    fprintf (stderr, "Created new symbol %s\n", ptr->new_name);
    494 		}
    495 	    }
    496 
    497 	  if (new_hash == NULL)
    498 	    {
    499 	      _bfd_error_handler (_("%B: Failed to add renamed symbol %s"),
    500 				  input_bfd, ptr->new_name);
    501 	      continue;
    502 	    }
    503 
    504 	  /* Convert the new_hash value into a index into the table of symbol hashes.  */
    505 	  for (h = sym_hashes; h < sym_hashes_end; h ++)
    506 	    {
    507 	      if (* h == new_hash)
    508 		{
    509 		  ptr->new_symndx = h - sym_hashes + num_local_syms;
    510 		  if (SYMBIAN_DEBUG)
    511 		    fprintf (stderr, "Converted new hash to index of %ld\n", ptr->new_symndx);
    512 		  break;
    513 		}
    514 	    }
    515 	  /* If the new symbol is not in the hash table then it must be
    516 	     because it is one of the newly created undefined symbols
    517 	     manufactured above.  So we extend the sym has table here to
    518 	     include this extra symbol.  */
    519 	  if (h == sym_hashes_end)
    520 	    {
    521 	      struct elf_link_hash_entry **  new_sym_hashes;
    522 
    523 	      /* This is not very efficient, but it works.  */
    524 	      ++ num_global_syms;
    525 	      new_sym_hashes = bfd_alloc (input_bfd, num_global_syms * sizeof * sym_hashes);
    526 	      if (new_sym_hashes == NULL)
    527 		{
    528 		  if (SYMBIAN_DEBUG)
    529 		    fprintf (stderr, "Out of memory extending hash table\n");
    530 		  continue;
    531 		}
    532 	      memcpy (new_sym_hashes, sym_hashes, (num_global_syms - 1) * sizeof * sym_hashes);
    533 	      new_sym_hashes[num_global_syms - 1] = new_hash;
    534 	      elf_sym_hashes (input_bfd) = sym_hashes = new_sym_hashes;
    535 	      sym_hashes_end = sym_hashes + num_global_syms;
    536 	      symtab_hdr->sh_size  = (num_global_syms + num_local_syms) * sizeof (Elf32_External_Sym);
    537 
    538 	      ptr->new_symndx = num_global_syms - 1 + num_local_syms;
    539 
    540 	      if (SYMBIAN_DEBUG)
    541 		fprintf (stderr, "Extended symbol hash table to insert new symbol as index %ld\n",
    542 			 ptr->new_symndx);
    543 	    }
    544 	}
    545 
    546       /* Walk the reloc list looking for references to renamed symbols.
    547 	 When we find one, we alter the index in the reloc to point to the new symbol.  */
    548       for (rel = relocs, relend = relocs + input_section->reloc_count;
    549 	   rel < relend;
    550 	   rel ++)
    551 	{
    552 	  int                          r_type;
    553 	  unsigned long                r_symndx;
    554 	  struct elf_link_hash_entry * h;
    555 
    556 	  r_symndx = ELF32_R_SYM (rel->r_info);
    557 	  r_type = ELF32_R_TYPE (rel->r_info);
    558 
    559 	  /* Ignore unused relocs.  */
    560 	  if ((r_type >= (int) R_SH_GNU_VTINHERIT
    561 	       && r_type <= (int) R_SH_LABEL)
    562 	      || r_type == (int) R_SH_NONE
    563 	      || r_type < 0
    564 	      || r_type >= R_SH_max)
    565 	    continue;
    566 
    567 	  /* Ignore relocs against local symbols.  */
    568 	  if (r_symndx < num_local_syms)
    569 	    continue;
    570 
    571 	  BFD_ASSERT (r_symndx < (num_global_syms + num_local_syms));
    572 	  h = sym_hashes[r_symndx - num_local_syms];
    573 	  BFD_ASSERT (h != NULL);
    574 
    575 	  while (   h->root.type == bfd_link_hash_indirect
    576 		 || h->root.type == bfd_link_hash_warning)
    577 	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
    578 
    579 	  /* If the symbol is defined there is no need to rename it.
    580 	     XXX - is this true ?  */
    581 	  if (   h->root.type == bfd_link_hash_defined
    582 	      || h->root.type == bfd_link_hash_defweak
    583 	      || h->root.type == bfd_link_hash_undefweak)
    584 	    continue;
    585 
    586 	  for (ptr = rename_list; ptr; ptr = ptr->next)
    587 	    if (h == ptr->current_hash)
    588 	      {
    589 		BFD_ASSERT (ptr->new_symndx);
    590 		if (SYMBIAN_DEBUG)
    591 		  fprintf (stderr, "convert reloc %lx from using index %ld to using index %ld\n",
    592 			   (unsigned long) rel->r_info,
    593 			   (long) ELF32_R_SYM (rel->r_info), ptr->new_symndx);
    594 		rel->r_info = ELF32_R_INFO (ptr->new_symndx, r_type);
    595 		break;
    596 	      }
    597 	}
    598     }
    599 
    600   return sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
    601 				  contents, relocs, local_syms, local_sections);
    602 }
    603 
    604 #define TARGET_LITTLE_SYM	sh_elf32_symbian_le_vec
    605 #define TARGET_LITTLE_NAME      "elf32-shl-symbian"
    606 
    607 #undef  elf_backend_relocate_section
    608 #define elf_backend_relocate_section	sh_symbian_relocate_section
    609 #undef  elf_backend_check_directives
    610 #define elf_backend_check_directives    sh_symbian_process_directives
    611 
    612 #include "elf32-target.h"
    613