[binutils] Bump binutils to 2.20.1

binutils/bfd/elf32-spu.c

 /* SPU specific support for 32-bit ELF
 
    Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 313 matching lines @@
   /* Total number of overlays.  */
   unsigned int num_overlays;
 
   /* For soft icache.  */
   unsigned int line_size_log2;
   unsigned int num_lines_log2;
   unsigned int fromelem_size_log2;
 
   /* How much memory we have.  */
   unsigned int local_store;
-  /* Local store --auto-overlay should reserve for non-overlay
-     functions and data.  */
-  unsigned int overlay_fixed;
-  /* Local store --auto-overlay should reserve for stack and heap.  */
-  unsigned int reserved;
-  /* If reserved is not specified, stack analysis will calculate a value
-     for the stack.  This parameter adjusts that value to allow for
-     negative sp access (the ABI says 2000 bytes below sp are valid,
-     and the overlay manager uses some of this area).  */
-  int extra_stack_space;
+
   /* Count of overlay stubs needed in non-overlay area.  */
   unsigned int non_ovly_stub;
 
   /* Pointer to the fixup section */
   asection *sfixup;
 
   /* Set on error.  */
   unsigned int stub_err : 1;
 };
 
@@ skipping 2331 matching lines @@
   irela = internal_relocs;
   irelaend = irela + sec->reloc_count;
   for (; irela < irelaend; irela++)
     {
       enum elf_spu_reloc_type r_type;
       unsigned int r_indx;
       asection *sym_sec;
       Elf_Internal_Sym *sym;
       struct elf_link_hash_entry *h;
       bfd_vma val;
-      bfd_boolean reject, is_call;
+      bfd_boolean nonbranch, is_call;
       struct function_info *caller;
       struct call_info *callee;
 
-      reject = FALSE;
       r_type = ELF32_R_TYPE (irela->r_info);
-      if (r_type != R_SPU_REL16
-          && r_type != R_SPU_ADDR16)
-        {
-          reject = TRUE;
-          if (!(call_tree && spu_hash_table (info)->params->auto_overlay))
-            continue;
-        }
+      nonbranch = r_type != R_SPU_REL16 && r_type != R_SPU_ADDR16;
 
       r_indx = ELF32_R_SYM (irela->r_info);
       if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, sec->owner))
         return FALSE;
 
       if (sym_sec == NULL
           || sym_sec->output_section == bfd_abs_section_ptr)
         continue;
 
       is_call = FALSE;
-      if (!reject)
+      if (!nonbranch)
         {
           unsigned char insn[4];
 
           if (!bfd_get_section_contents (sec->owner, sec, insn,
                                          irela->r_offset, 4))
             return FALSE;
           if (is_branch (insn))
             {
               is_call = (insn[0] & 0xfd) == 0x31;
               priority = insn[1] & 0x0f;
@@ skipping 10 matching lines @@
                       (_("%B(%A+0x%v): call to non-code section"
                          " %B(%A), analysis incomplete\n"),
                        sec->owner, sec, irela->r_offset,
                        sym_sec->owner, sym_sec);
                   warned = TRUE;
                   continue;
                 }
             }
           else
             {
-              reject = TRUE;
-              if (!(call_tree && spu_hash_table (info)->params->auto_overlay)
-                  || is_hint (insn))
+              nonbranch = TRUE;
+              if (is_hint (insn))
                 continue;
             }
         }
 
-      if (reject)
+      if (nonbranch)
         {
           /* For --auto-overlay, count possible stubs we need for
              function pointer references.  */
           unsigned int sym_type;
           if (h)
             sym_type = h->type;
           else
             sym_type = ELF_ST_TYPE (sym->st_info);
           if (sym_type == STT_FUNC)
-            spu_hash_table (info)->non_ovly_stub += 1;
-          continue;
+            {
+              if (call_tree && spu_hash_table (info)->params->auto_overlay)
+                spu_hash_table (info)->non_ovly_stub += 1;
+              /* If the symbol type is STT_FUNC then this must be a
+                 function pointer initialisation.  */
+              continue;
+            }
+          /* Ignore data references.  */
+          if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
+              != (SEC_ALLOC | SEC_LOAD | SEC_CODE))
+            continue;
+          /* Otherwise we probably have a jump table reloc for
+             a switch statement or some other reference to a
+             code label.  */
         }
 
       if (h)
         val = h->root.u.def.value;
       else
         val = sym->st_value;
       val += irela->r_addend;
 
       if (!call_tree)
         {
@@ skipping 28 matching lines @@
       if (callee == NULL)
         return FALSE;
 
       callee->fun = find_function (sym_sec, val, info);
       if (callee->fun == NULL)
         return FALSE;
       callee->is_tail = !is_call;
       callee->is_pasted = FALSE;
       callee->broken_cycle = FALSE;
       callee->priority = priority;
-      callee->count = 1;
+      callee->count = nonbranch? 0 : 1;
       if (callee->fun->last_caller != sec)
         {
           callee->fun->last_caller = sec;
           callee->fun->call_count += 1;
         }
       if (!insert_callee (caller, callee))
         free (callee);
       else if (!is_call
                && !callee->fun->is_func
                && callee->fun->stack == 0)
@@ skipping 1325 matching lines @@
 
 /* Handle --auto-overlay.  */
 
 static void
 spu_elf_auto_overlay (struct bfd_link_info *info)
 {
   bfd *ibfd;
   bfd **bfd_arr;
   struct elf_segment_map *m;
   unsigned int fixed_size, lo, hi;
+  unsigned int reserved;
   struct spu_link_hash_table *htab;
   unsigned int base, i, count, bfd_count;
   unsigned int region, ovlynum;
   asection **ovly_sections, **ovly_p;
   unsigned int *ovly_map;
   FILE *script;
   unsigned int total_overlay_size, overlay_size;
   const char *ovly_mgr_entry;
   struct elf_link_hash_entry *h;
   struct _mos_param mos_param;
@@ skipping 15 matching lines @@
           }
   fixed_size = hi + 1 - lo;
 
   if (!discover_functions (info))
     goto err_exit;
 
   if (!build_call_tree (info))
     goto err_exit;
 
   htab = spu_hash_table (info);
-  if (htab->reserved == 0)
+  reserved = htab->params->auto_overlay_reserved;
+  if (reserved == 0)
     {
       struct _sum_stack_param sum_stack_param;
 
       sum_stack_param.emit_stack_syms = 0;
       sum_stack_param.overall_stack = 0;
       if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
         goto err_exit;
-      htab->reserved = sum_stack_param.overall_stack + htab->extra_stack_space;
+      reserved = (sum_stack_param.overall_stack
+                  + htab->params->extra_stack_space);
     }
 
   /* No need for overlays if everything already fits.  */
-  if (fixed_size + htab->reserved <= htab->local_store
+  if (fixed_size + reserved <= htab->local_store
       && htab->params->ovly_flavour != ovly_soft_icache)
     {
       htab->params->auto_overlay = 0;
       return;
     }
 
   uos_param.exclude_input_section = 0;
   uos_param.exclude_output_section
     = bfd_get_section_by_name (info->output_bfd, ".interrupt");
 
@@ skipping 92 matching lines @@
       if (!ok)
         {
           info->callbacks->einfo (_("sorry, no support for duplicate "
                                     "object files in auto-overlay script\n"));
           bfd_set_error (bfd_error_bad_value);
           goto err_exit;
         }
     }
   free (bfd_arr);
 
-  fixed_size += htab->reserved;
+  fixed_size += reserved;
   fixed_size += htab->non_ovly_stub * ovl_stub_size (htab->params);
   if (fixed_size + mos_param.max_overlay_size <= htab->local_store)
     {
       if (htab->params->ovly_flavour == ovly_soft_icache)
         {
           /* Stubs in the non-icache area are bigger.  */
           fixed_size += htab->non_ovly_stub * 16;
           /* Space for icache manager tables.
              a) Tag array, one quadword per cache line.
              - word 0: ia address of present line, init to zero.  */
@@ skipping 18 matching lines @@
         }
     }
 
   if (fixed_size + mos_param.max_overlay_size > htab->local_store)
     info->callbacks->einfo (_("non-overlay size of 0x%v plus maximum overlay "
                               "size of 0x%v exceeds local store\n"),
                             (bfd_vma) fixed_size,
                             (bfd_vma) mos_param.max_overlay_size);
 
   /* Now see if we should put some functions in the non-overlay area.  */
-  else if (fixed_size < htab->overlay_fixed)
+  else if (fixed_size < htab->params->auto_overlay_fixed)
     {
       unsigned int max_fixed, lib_size;
 
       max_fixed = htab->local_store - mos_param.max_overlay_size;
-      if (max_fixed > htab->overlay_fixed)
-        max_fixed = htab->overlay_fixed;
+      if (max_fixed > htab->params->auto_overlay_fixed)
+        max_fixed = htab->params->auto_overlay_fixed;
       lib_size = max_fixed - fixed_size;
       lib_size = auto_ovl_lib_functions (info, lib_size);
       if (lib_size == (unsigned int) -1)
         goto err_exit;
       fixed_size = max_fixed - lib_size;
     }
 
   /* Build an array of sections, suitably sorted to place into
      overlays.  */
   ovly_sections = bfd_malloc (2 * count * sizeof (*ovly_sections));
@@ skipping 1089 matching lines @@
 
 #define elf_backend_additional_program_headers  spu_elf_additional_program_headers
 #define elf_backend_modify_segment_map          spu_elf_modify_segment_map
 #define elf_backend_modify_program_headers      spu_elf_modify_program_headers
 #define elf_backend_post_process_headers        spu_elf_post_process_headers
 #define elf_backend_fake_sections               spu_elf_fake_sections
 #define elf_backend_special_sections            spu_elf_special_sections
 #define bfd_elf32_bfd_final_link                spu_elf_final_link
 
 #include "elf32-target.h"