[PATCH] Fix type and alignment of ARM/Thumb EABI mapping symbols

[Julian Brown <julian@codesourcery.com>]

[-- Attachment #1: Type: text/plain, Size: 2926 bytes --]

Hi,

This patch fixes two problems: the type of mapping symbols is made 
STT_NOTYPE (from STT_FUNC or STT_OBJECT from ARM/Thumb or data 
respectively), and the alignment is corrected to not have the low bit 
set for Thumb mapping symbols, in accordance with the latest version of 
the ARM AAELF spec.

Unfortunately altering the symbol type to STT_NOTYPE for mapping symbols 
affects the output of disassembly from objdump. $a and $t were 
previously treated as functions. When objdump tried to find the closest 
symbol for possibly-symbol-relative offsets previously, it found those 
mapping symbols since compare_symbols places functions first in a sorted 
version of the symbol table. They were then rejected by the 
symbol_is_valid hook (arm_symbol_is_valid) from the disassemble_info 
struct, and the section name was printed instead.

When the type of mapping symbols is changed to STT_NOTYPE, they are no 
longer placed first in the sorted symbol list, so another symbol is used 
instead. This causes test regressions, e.g. a symbol-offset address 
which was previously output as:

   bl      8224 <.text-0xc>

was output instead as:

   bl      8224 <_start-0xc>

In the interest of preserving existing behaviour, I have fixed this by 
adding a new disassemble_info hook which allows the symbol table used 
for disassembly to have a target-specific hook for altering each symbol 
(or remove it) in the remove_useless_symbols function. This sets the 
BSF_FUNCTION flag for mapping symbols, which makes things behave the way 
they used to, and possibly provides useful functionality for other 
platforms as well.

It may be better to just change the expected test output instead. Thoughts?

Tested on arm-none-eabi, arm-none-symbianelf, and i686-pc-linux-gnu with 
all targets.

OK to apply?

ChangeLog:

   * bfd/elf32-arm.c (arm_elf_find_function): include STT_NOTYPE in test
   for mapping symbols.
   * binutils/objdump.c (remove_useless_symbols): Add disassemble_info
   parameter, and call new hook to filter symbols in a target-specific
   way.
   (disassemble_data): Initialise sorted symbols after disassemble_info
   struct, and call remove_useless_symbols before sorting.
   * gas/config/tc-arm.c (mapping_state): Update documentation in
   function comment. Change type of all mapping symbols to BSF_NO_FLAGS.
   (is_mapping_symbol_name): New function.
   (arm_adjust_symtab): Don't adjust type of mapping symbols here.
   * gas/testsuite/gas/arm/mapping.d: Change expected output for untyped
   symbols.
   * include/dis-asm.h (disassemble_info): Add filter_symbol hook.
   (arm_filter_symbol): Add prototype.
   * opcodes/arm-dis.c (arm_filter_symbol): New function to add
   BSF_FUNCTION for code mapping symbols.
   * opcodes/dis-init.c (init_disassemble_info): Initialise filter_symbol
   hook (NULL).
   * opcodes/disassemble.c (disassemble_init_for_target): Initialise
   filter_symbol hook for ARM.


[-- Attachment #2: patch-3 --]
[-- Type: text/plain, Size: 18522 bytes --]

? bfd/doc/bfd.info
? bfd/doc/bfd.info-1
? gas/doc/as.info
? gas/doc/as.info-1
? gprof/gprof.info
? gprof/gprof.info-1
Index: bfd/elf32-arm.c
===================================================================
RCS file: /cvs/src/src/bfd/elf32-arm.c,v
retrieving revision 1.26
diff -c -p -r1.26 elf32-arm.c
*** bfd/elf32-arm.c	22 Mar 2005 15:39:32 -0000	1.26
--- bfd/elf32-arm.c	27 Mar 2005 19:47:21 -0000
*************** arm_elf_find_function (bfd *         abf
*** 4261,4272 ****
  	  break;
  	case STT_FUNC:
  	case STT_ARM_TFUNC:
  	  /* Skip $a and $t symbols.  */
  	  if ((q->symbol.flags & BSF_LOCAL)
  	      && is_arm_mapping_symbol_name (q->symbol.name))
  	    continue;
  	  /* Fall through.  */
- 	case STT_NOTYPE:
  	  if (bfd_get_section (&q->symbol) == section
  	      && q->symbol.value >= low_func
  	      && q->symbol.value <= offset)
--- 4261,4272 ----
  	  break;
  	case STT_FUNC:
  	case STT_ARM_TFUNC:
+ 	case STT_NOTYPE:
  	  /* Skip $a and $t symbols.  */
  	  if ((q->symbol.flags & BSF_LOCAL)
  	      && is_arm_mapping_symbol_name (q->symbol.name))
  	    continue;
  	  /* Fall through.  */
  	  if (bfd_get_section (&q->symbol) == section
  	      && q->symbol.value >= low_func
  	      && q->symbol.value <= offset)
Index: binutils/objdump.c
===================================================================
RCS file: /cvs/src/src/binutils/objdump.c,v
retrieving revision 1.102
diff -c -p -r1.102 objdump.c
*** binutils/objdump.c	18 Mar 2005 16:28:13 -0000	1.102
--- binutils/objdump.c	27 Mar 2005 19:47:22 -0000
*************** slurp_dynamic_symtab (bfd *abfd)
*** 454,460 ****
     Return the number of useful symbols.  */
  
  static long
! remove_useless_symbols (asymbol **symbols, long count)
  {
    asymbol **in_ptr = symbols, **out_ptr = symbols;
  
--- 454,460 ----
     Return the number of useful symbols.  */
  
  static long
! remove_useless_symbols (asymbol **symbols, long count, disassemble_info *info)
  {
    asymbol **in_ptr = symbols, **out_ptr = symbols;
  
*************** remove_useless_symbols (asymbol **symbol
*** 469,474 ****
--- 469,477 ----
        if (bfd_is_und_section (sym->section)
  	  || bfd_is_com_section (sym->section))
  	continue;
+       if (info->filter_symbol
+ 	  && ! info->filter_symbol (sym))
+ 	continue;
  
        *out_ptr++ = sym;
      }
*************** disassemble_data (bfd *abfd)
*** 1844,1867 ****
    prev_functionname = NULL;
    prev_line = -1;
  
-   /* We make a copy of syms to sort.  We don't want to sort syms
-      because that will screw up the relocs.  */
-   sorted_symcount = symcount ? symcount : dynsymcount;
-   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
-   memcpy (sorted_syms, symcount ? syms : dynsyms,
- 	  sorted_symcount * sizeof (asymbol *));
- 
-   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
- 
-   for (i = 0; i < synthcount; ++i)
-     {
-       sorted_syms[sorted_symcount] = synthsyms + i;
-       ++sorted_symcount;
-     }
- 
-   /* Sort the symbols into section and symbol order.  */
-   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
- 
    init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
  
    disasm_info.application_data = (void *) &aux;
--- 1847,1852 ----
*************** disassemble_data (bfd *abfd)
*** 1926,1931 ****
--- 1911,1937 ----
    /* Allow the target to customize the info structure.  */
    disassemble_init_for_target (& disasm_info);
  
+   /* We make a copy of syms to sort.  We don't want to sort syms
+      because that will screw up the relocs.  */
+   sorted_symcount = symcount ? symcount : dynsymcount;
+   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
+   memcpy (sorted_syms, symcount ? syms : dynsyms,
+ 	  sorted_symcount * sizeof (asymbol *));
+ 
+   /* Remove useless symbols before sorting (remove_useless_symbols may also
+      mutate some symbols to affect sort order).  */
+   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount,
+                                             &disasm_info);
+ 
+   for (i = 0; i < synthcount; ++i)
+     {
+       sorted_syms[sorted_symcount] = synthsyms + i;
+       ++sorted_symcount;
+     }
+ 
+   /* Sort the symbols into section and symbol order.  */
+   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
+ 
    /* Pre-load the dynamic relocs if we are going
       to be dumping them along with the disassembly.  */
    if (dump_dynamic_reloc_info)
Index: gas/config/tc-arm.c
===================================================================
RCS file: /cvs/src/src/gas/config/tc-arm.c,v
retrieving revision 1.197
diff -c -p -r1.197 tc-arm.c
*** gas/config/tc-arm.c	23 Mar 2005 15:49:02 -0000	1.197
--- gas/config/tc-arm.c	27 Mar 2005 19:47:22 -0000
*************** validate_offset_imm (unsigned int val, i
*** 1238,1311 ****
  \f
  #ifdef OBJ_ELF
  /* This code is to handle mapping symbols as defined in the ARM ELF spec.
!    (This text is taken from version B-02 of the spec):
  
!       4.4.7 Mapping and tagging symbols
  
!       A section of an ARM ELF file can contain a mixture of ARM code,
!       Thumb code, and data.  There are inline transitions between code
!       and data at literal pool boundaries. There can also be inline
!       transitions between ARM code and Thumb code, for example in
!       ARM-Thumb inter-working veneers.  Linkers, machine-level
!       debuggers, profiling tools, and disassembly tools need to map
!       images accurately. For example, setting an ARM breakpoint on a
!       Thumb location, or in a literal pool, can crash the program
!       being debugged, ruining the debugging session.
! 
!       ARM ELF entities are mapped (see section 4.4.7.1 below) and
!       tagged (see section 4.4.7.2 below) using local symbols (with
!       binding STB_LOCAL).  To assist consumers, mapping and tagging
!       symbols should be collated first in the symbol table, before
!       other symbols with binding STB_LOCAL.
! 
!       To allow properly collated mapping and tagging symbols to be
!       skipped by consumers that have no interest in them, the first
!       such symbol should have the name $m and its st_value field equal
!       to the total number of mapping and tagging symbols (including
!       the $m) in the symbol table.
! 
!       4.4.7.1 Mapping symbols
! 
!       $a    Labels the first byte of a sequence of ARM instructions.
!             Its type is STT_FUNC.
! 
!       $d    Labels the first byte of a sequence of data items.
!             Its type is STT_OBJECT.
! 
!       $t    Labels the first byte of a sequence of Thumb instructions.
!             Its type is STT_FUNC.
! 
!       This list of mapping symbols may be extended in the future.
! 
!       Section-relative mapping symbols
! 
!       Mapping symbols defined in a section define a sequence of
!       half-open address intervals that cover the address range of the
!       section. Each interval starts at the address defined by a
!       mapping symbol, and continues up to, but not including, the
!       address defined by the next (in address order) mapping symbol or
!       the end of the section. A corollary is that there must be a
!       mapping symbol defined at the beginning of each section.
!       Consumers can ignore the size of a section-relative mapping
!       symbol. Producers can set it to 0.
! 
!       Absolute mapping symbols
! 
!       Because of the need to crystallize a Thumb address with the
!       Thumb-bit set, absolute symbol of type STT_FUNC (symbols of type
!       STT_FUNC defined in section SHN_ABS) need to be mapped with $a
!       or $t.
! 
!       The extent of a mapping symbol defined in SHN_ABS is [st_value,
!       st_value + st_size), or [st_value, st_value + 1) if st_size = 0,
!       where [x, y) denotes the half-open address range from x,
!       inclusive, to y, exclusive.
! 
!       In the absence of a mapping symbol, a consumer can interpret a
!       function symbol with an odd value as the Thumb code address
!       obtained by clearing the least significant bit of the
!       value. This interpretation is deprecated, and it may not work in
!       the future.
  
     Note - the Tagging symbols ($b, $f, $p $m) have been dropped from
     the EABI (which is still under development), so they are not
--- 1238,1303 ----
  \f
  #ifdef OBJ_ELF
  /* This code is to handle mapping symbols as defined in the ARM ELF spec.
!    (This text is taken from version 0.62 RC 2 of the spec):
  
!       4.5.7 Mapping symbols
  
!       A section of an ELF file can contain a mixture of ARM code, Thumb code
!       and data.
! 
!       There are inline transitions between code and data at literal pool
!       boundaries.  There can also be inline transitions between ARM code and
!       Thumb code, for example in ARM-Thumb inter-working veneers.
! 
!       Linkers, and potentially other tools, need to map images correctly (for
!       example, to support byte swapping to produce a BE-8 image from a BE-32
!       object file).  To support this, a number of symbols, termed mapping
!       symbols appear in the symbol table to denote the start of a sequence of
!       bytes of the appropriate type.  All mapping symbols have type STT_NOTYPE
!       and binding STB_LOCAL.  The st_size field is unused and must be zero.
! 
!       The mapping symbols are defined in Table 4-6, Mapping symbols.  It is an
!       error for a relocation to reference a mapping symbol.  Two forms of
!       mapping symbol are supported:
! 
!         * a short form, that uses a dollar character and a single letter
! 	  denoting the class.  This form can be used when an object producer
! 	  creates mapping symbols automatically, and minimizes symbol table
! 	  space
! 
!         * a longer form, where the short form is extended with a period and
! 	  then any sequence of characters that are legal for a symbol.  This
! 	  form can be used when assembler files have to be annotated manually
! 	  and the assembler does not support multiple definitions of symbols. 
! 
!       Table 4-6, Mapping symbols
! 
! 	Name         Meaning
! 
! 	$a           Start of a sequence of ARM instructions
! 	$a.<any...>
! 
! 	$d           Start of a sequence of data items (for example, a literal
! 	$d.<any...>  pool)
! 
! 	$t           Start of a sequence of Thumb instructions
! 	$t.<any...>
! 
!       4.5.7.1 Section-relative mapping symbols
!  
!       Mapping symbols defined in a section define a sequence of half-open
!       address intervals that cover the address range of the section.  Each
!       interval starts at the address defined by the mapping symbol, and
!       continues up to, but not including, the address defined by the next (in
!       address order) mapping symbol or the end of the section.  A section must
!       have a mapping symbol defined at the beginning of the section; however,
!       if the section contains only data then the mapping symbol may be omitted.
! 
!       4.5.7.2 Absolute mapping symbols
! 
!       Mapping symbols are no-longer required for the absolute section.  The
!       equivalent information is now conveyed by the type of the absolute
!       symbol.
  
     Note - the Tagging symbols ($b, $f, $p $m) have been dropped from
     the EABI (which is still under development), so they are not
*************** mapping_state (enum mstate state)
*** 1331,1345 ****
      {
      case MAP_DATA:
        symname = "$d";
!       type = BSF_OBJECT;
        break;
      case MAP_ARM:
        symname = "$a";
!       type = BSF_FUNCTION;
        break;
      case MAP_THUMB:
        symname = "$t";
!       type = BSF_FUNCTION;
        break;
      case MAP_UNDEFINED:
        return;
--- 1323,1337 ----
      {
      case MAP_DATA:
        symname = "$d";
!       type = BSF_NO_FLAGS;
        break;
      case MAP_ARM:
        symname = "$a";
!       type = BSF_NO_FLAGS;
        break;
      case MAP_THUMB:
        symname = "$t";
!       type = BSF_NO_FLAGS;
        break;
      case MAP_UNDEFINED:
        return;
*************** arm_frob_label (symbolS * sym)
*** 13645,13650 ****
--- 13637,13652 ----
      }
  }
  
+ /* Recognize short-form or long-form mapping symbol names.  */
+ 
+ static bfd_boolean
+ is_arm_mapping_symbol_name (const char* name)
+ {
+   return name && name[0] == '$'
+ 	 && (name[1] == 'a' || name[1] == 'd' || name[1] == 't')
+ 	 && (name[2] == '\0' || name[2] == '.');
+ }
+ 
  /* Adjust the symbol table.  This marks Thumb symbols as distinct from
     ARM ones.  */
  
*************** arm_adjust_symtab (void)
*** 13705,13718 ****
  	  elf_sym = elf_symbol (symbol_get_bfdsym (sym));
  	  bind = ELF_ST_BIND (elf_sym->internal_elf_sym.st_info);
  
! 	  /* If it's a .thumb_func, declare it as so,
! 	     otherwise tag label as .code 16.  */
! 	  if (THUMB_IS_FUNC (sym))
! 	    elf_sym->internal_elf_sym.st_info =
! 	      ELF_ST_INFO (bind, STT_ARM_TFUNC);
! 	  else
! 	    elf_sym->internal_elf_sym.st_info =
! 	      ELF_ST_INFO (bind, STT_ARM_16BIT);
  	}
      }
  #endif
--- 13707,13723 ----
  	  elf_sym = elf_symbol (symbol_get_bfdsym (sym));
  	  bind = ELF_ST_BIND (elf_sym->internal_elf_sym.st_info);
  
! 	  if (!is_arm_mapping_symbol_name (elf_sym->symbol.name))
! 	    {
! 	      /* If it's a .thumb_func, declare it as so,
! 		 otherwise tag label as .code 16.  */
! 	      if (THUMB_IS_FUNC (sym))
! 		elf_sym->internal_elf_sym.st_info =
! 		  ELF_ST_INFO (bind, STT_ARM_TFUNC);
! 	      else
! 		elf_sym->internal_elf_sym.st_info =
! 		  ELF_ST_INFO (bind, STT_ARM_16BIT);
! 	    }
  	}
      }
  #endif
Index: gas/testsuite/gas/arm/mapping.d
===================================================================
RCS file: /cvs/src/src/gas/testsuite/gas/arm/mapping.d,v
retrieving revision 1.4
diff -c -p -r1.4 mapping.d
*** gas/testsuite/gas/arm/mapping.d	11 Dec 2004 04:32:36 -0000	1.4
--- gas/testsuite/gas/arm/mapping.d	27 Mar 2005 19:47:24 -0000
*************** SYMBOL TABLE:
*** 9,18 ****
  0+00 l    d  .text	0+0 (|.text)
  0+00 l    d  .data	0+0 (|.data)
  0+00 l    d  .bss	0+0 (|.bss)
! 0+00 l     F .text	0+0 \$a
! 0+08 l     F .text	0+0 \$t
! 0+00 l     O .data	0+0 \$d
  0+00 l    d  foo	0+0 (|foo)
! 0+00 l     F foo	0+0 \$t
  0+00 g       .text	0+0 mapping
  0+08 g     F .text	0+0 thumb_mapping
--- 9,18 ----
  0+00 l    d  .text	0+0 (|.text)
  0+00 l    d  .data	0+0 (|.data)
  0+00 l    d  .bss	0+0 (|.bss)
! 0+00 l       .text	0+0 \$a
! 0+08 l       .text	0+0 \$t
! 0+00 l       .data	0+0 \$d
  0+00 l    d  foo	0+0 (|foo)
! 0+00 l       foo	0+0 \$t
  0+00 g       .text	0+0 mapping
  0+08 g     F .text	0+0 thumb_mapping
Index: include/dis-asm.h
===================================================================
RCS file: /cvs/src/src/include/dis-asm.h,v
retrieving revision 1.50
diff -c -p -r1.50 dis-asm.h
*** include/dis-asm.h	3 Mar 2005 11:58:01 -0000	1.50
--- include/dis-asm.h	27 Mar 2005 19:47:27 -0000
*************** typedef struct disassemble_info {
*** 136,142 ****
       displaying debugging outout.  */
    bfd_boolean (* symbol_is_valid)
      (asymbol *, struct disassemble_info * info);
!     
    /* These are for buffer_read_memory.  */
    bfd_byte *buffer;
    bfd_vma buffer_vma;
--- 136,148 ----
       displaying debugging outout.  */
    bfd_boolean (* symbol_is_valid)
      (asymbol *, struct disassemble_info * info);
!  
!   /* Filter symbols used in disassembly, in a target-dependent fashion.
!      Return TRUE if symbol should be retained, or FALSE to remove it. May also
!      modify symbols in-place.  */
!   bfd_boolean (* filter_symbol)
!     (asymbol *);
! 
    /* These are for buffer_read_memory.  */
    bfd_byte *buffer;
    bfd_vma buffer_vma;
*************** extern int get_arm_regname_num_options (
*** 275,280 ****
--- 281,287 ----
  extern int set_arm_regname_option (int);
  extern int get_arm_regnames (int, const char **, const char **, const char ***);
  extern bfd_boolean arm_symbol_is_valid (asymbol *, struct disassemble_info *);
+ extern bfd_boolean arm_filter_symbol (asymbol *);
  
  /* Fetch the disassembler for a given BFD, if that support is available.  */
  extern disassembler_ftype disassembler (bfd *);
Index: opcodes/arm-dis.c
===================================================================
RCS file: /cvs/src/src/opcodes/arm-dis.c,v
retrieving revision 1.44
diff -c -p -r1.44 arm-dis.c
*** opcodes/arm-dis.c	12 Mar 2005 18:25:47 -0000	1.44
--- opcodes/arm-dis.c	27 Mar 2005 19:47:30 -0000
*************** arm_symbol_is_valid (asymbol * sym,
*** 1937,1942 ****
--- 1937,1964 ----
    return (name && *name != '$');
  }
  
+ /* Filter symbols used for disassembly (alter mapping symbols).  */
+ 
+ bfd_boolean
+ arm_filter_symbol (asymbol *sym)
+ {
+   const char *name;
+ 
+   if (sym == NULL)
+     return TRUE;
+ 
+   name = bfd_asymbol_name (sym);
+ 
+   /* ARM/Thumb mapping symbols used to be treated as functions when sorting
+      symbols before disassembly. This makes them behave as if they still
+      were.  */
+   if (name && name[0] == '$'
+       && (name[1] == 'a' || name[1] == 't'))
+     sym->flags |= BSF_FUNCTION;
+ 
+   return TRUE;
+ }
+ 
  /* Parse an individual disassembler option.  */
  
  void
Index: opcodes/dis-init.c
===================================================================
RCS file: /cvs/src/src/opcodes/dis-init.c,v
retrieving revision 1.2
diff -c -p -r1.2 dis-init.c
*** opcodes/dis-init.c	14 Nov 2003 15:12:44 -0000	1.2
--- opcodes/dis-init.c	27 Mar 2005 19:47:30 -0000
*************** init_disassemble_info (struct disassembl
*** 38,43 ****
--- 38,44 ----
    info->print_address_func = generic_print_address;
    info->symbol_at_address_func = generic_symbol_at_address;
    info->symbol_is_valid = generic_symbol_is_valid;
+   info->filter_symbol = NULL;
    info->display_endian = BFD_ENDIAN_UNKNOWN;
  }
  
Index: opcodes/disassemble.c
===================================================================
RCS file: /cvs/src/src/opcodes/disassemble.c,v
retrieving revision 1.50
diff -c -p -r1.50 disassemble.c
*** opcodes/disassemble.c	3 Mar 2005 11:49:48 -0000	1.50
--- opcodes/disassemble.c	27 Mar 2005 19:47:30 -0000
*************** disassemble_init_for_target (struct disa
*** 422,427 ****
--- 422,428 ----
  #ifdef ARCH_arm
      case bfd_arch_arm:
        info->symbol_is_valid = arm_symbol_is_valid;
+       info->filter_symbol = arm_filter_symbol;
        break;
  #endif
  #ifdef ARCH_ia64