rockboxdev: Store toolchain patches in-tree, instead of downloading them

This frees us from having to keep the web site in sync.

Note that only currently-referenced patches were kept.

Change-Id: I50da1b75baeac214cf142c8b76a05a8c56b4c1d4

1 files changed, 569 insertions, 0 deletions

diff --git a/tools/toolchain-patches/binutils-2.20.1-ld-thumb-interwork-long-call.diff b/tools/toolchain-patches/binutils-2.20.1-ld-thumb-interwork-long-call.diff
new file mode 100644
index 0000000000..5eb5debfbf
--- /dev/null
+++ b/tools/toolchain-patches/binutils-2.20.1-ld-thumb-interwork-long-call.diff
@@ -0,0 +1,569 @@
+http://sourceware.org/ml/binutils/2010-02/msg00460.html
+
+Drop this patch when binutils 2.21 is out
+diff -ur binutils-2.20.1.orig/bfd/elf32-arm.c binutils-2.20.1/bfd/elf32-arm.c
+--- binutils-2.20.1.orig/bfd/elf32-arm.c        2010-06-11 18:48:06.000000000 +0200
++++ binutils-2.20.1/bfd/elf32-arm.c     2010-06-11 18:51:00.000000000 +0200
+@@ -2401,6 +2401,7 @@
+   unsigned long orig_insn;
+   char *stub_name;
+   enum elf32_arm_stub_type stub_type;
++  int st_type;
+ };
+ 
+ /* A table of relocs applied to branches which might trigger Cortex-A8
+@@ -2647,6 +2648,9 @@
+     asection *stub_sec;
+   } *stub_group;
+ 
++  /* Number of elements in stub_group.  */
++  int top_id;
++
+   /* Assorted information used by elf32_arm_size_stubs.  */
+   unsigned int bfd_count;
+   int top_index;
+@@ -2933,6 +2937,7 @@
+   ret->add_stub_section = NULL;
+   ret->layout_sections_again = NULL;
+   ret->stub_group = NULL;
++  ret->top_id = 0;
+   ret->bfd_count = 0;
+   ret->top_index = 0;
+   ret->input_list = NULL;
+@@ -3033,7 +3038,7 @@
+ arm_type_of_stub (struct bfd_link_info *info,
+                  asection *input_sec,
+                  const Elf_Internal_Rela *rel,
+-                 unsigned char st_type,
++                 int *actual_st_type,
+                  struct elf32_arm_link_hash_entry *hash,
+                  bfd_vma destination,
+                  asection *sym_sec,
+@@ -3048,6 +3053,7 @@
+   int thumb_only;
+   enum elf32_arm_stub_type stub_type = arm_stub_none;
+   int use_plt = 0;
++  int st_type = *actual_st_type;
+ 
+   /* We don't know the actual type of destination in case it is of
+      type STT_SECTION: give up.  */
+@@ -3065,14 +3071,15 @@
+              + input_sec->output_section->vma
+              + rel->r_offset);
+ 
+-  branch_offset = (bfd_signed_vma)(destination - location);
+-
+   r_type = ELF32_R_TYPE (rel->r_info);
+ 
+   /* Keep a simpler condition, for the sake of clarity.  */
+-  if (globals->splt != NULL && hash != NULL && hash->root.plt.offset != (bfd_vma) -1)
++  if (globals->splt != NULL
++      && hash != NULL
++      && hash->root.plt.offset != (bfd_vma) -1)
+     {
+       use_plt = 1;
++
+       /* Note when dealing with PLT entries: the main PLT stub is in
+         ARM mode, so if the branch is in Thumb mode, another
+         Thumb->ARM stub will be inserted later just before the ARM
+@@ -3081,8 +3088,15 @@
+         Thumb->Arm one and branch directly to the ARM PLT entry
+         because it avoids spreading offset corrections in several
+         places.  */
++
++      destination = (globals->splt->output_section->vma
++                    + globals->splt->output_offset
++                    + hash->root.plt.offset);
++      st_type = STT_FUNC;
+     }
+ 
++  branch_offset = (bfd_signed_vma)(destination - location);
++
+   if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
+     {
+       /* Handle cases where:
+@@ -3176,7 +3190,9 @@
+            }
+        }
+     }
+-  else if (r_type == R_ARM_CALL || r_type == R_ARM_JUMP24 || r_type == R_ARM_PLT32)
++  else if (r_type == R_ARM_CALL
++          || r_type == R_ARM_JUMP24
++          || r_type == R_ARM_PLT32)
+     {
+       if (st_type == STT_ARM_TFUNC)
+        {
+@@ -3231,6 +3247,12 @@
+        }
+     }
+ 
++  /* If a stub is needed, record the actual destination type.  */
++  if (stub_type != arm_stub_none)
++    {
++      *actual_st_type = st_type;
++    }
++
+   return stub_type;
+ }
+ 
+@@ -3240,31 +3262,35 @@
+ elf32_arm_stub_name (const asection *input_section,
+                     const asection *sym_sec,
+                     const struct elf32_arm_link_hash_entry *hash,
+-                    const Elf_Internal_Rela *rel)
++                    const Elf_Internal_Rela *rel,
++             enum elf32_arm_stub_type stub_type)
++
+ {
+   char *stub_name;
+   bfd_size_type len;
+ 
+   if (hash)
+     {
+-      len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1;
++      len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1 + 2 + 1;
+       stub_name = bfd_malloc (len);
+       if (stub_name != NULL)
+-       sprintf (stub_name, "%08x_%s+%x",
++       sprintf (stub_name, "%08x_%s+%x_%d",
+                 input_section->id & 0xffffffff,
+                 hash->root.root.root.string,
+-                (int) rel->r_addend & 0xffffffff);
++                (int) rel->r_addend & 0xffffffff,
++         (int) stub_type);
+     }
+   else
+     {
+-      len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
++      len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1 + 2 + 1;
+       stub_name = bfd_malloc (len);
+       if (stub_name != NULL)
+-       sprintf (stub_name, "%08x_%x:%x+%x",
++       sprintf (stub_name, "%08x_%x:%x+%x_%d",
+                 input_section->id & 0xffffffff,
+                 sym_sec->id & 0xffffffff,
+                 (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
+-                (int) rel->r_addend & 0xffffffff);
++                (int) rel->r_addend & 0xffffffff,
++         (int) stub_type);
+     }
+ 
+   return stub_name;
+@@ -3278,7 +3304,8 @@
+                          const asection *sym_sec,
+                          struct elf_link_hash_entry *hash,
+                          const Elf_Internal_Rela *rel,
+-                         struct elf32_arm_link_hash_table *htab)
++                         struct elf32_arm_link_hash_table *htab,
++                         enum elf32_arm_stub_type stub_type)
+ {
+   struct elf32_arm_stub_hash_entry *stub_entry;
+   struct elf32_arm_link_hash_entry *h = (struct elf32_arm_link_hash_entry *) hash;
+@@ -3296,7 +3323,8 @@
+ 
+   if (h != NULL && h->stub_cache != NULL
+       && h->stub_cache->h == h
+-      && h->stub_cache->id_sec == id_sec)
++      && h->stub_cache->id_sec == id_sec
++      && h->stub_cache->stub_type == stub_type)
+     {
+       stub_entry = h->stub_cache;
+     }
+@@ -3304,7 +3332,7 @@
+     {
+       char *stub_name;
+ 
+-      stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel);
++      stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel, stub_type);
+       if (stub_name == NULL)
+        return NULL;
+ 
+@@ -3464,7 +3492,7 @@
+     /* We have to do the a8 fixes last, as they are less aligned than
+        the other veneers.  */
+     return TRUE;
+-  
++
+   /* Make a note of the offset within the stubs for this entry.  */
+   stub_entry->stub_offset = stub_sec->size;
+   loc = stub_sec->contents + stub_entry->stub_offset;
+@@ -3499,17 +3527,17 @@
+                 BFD_ASSERT ((data & 0xff00) == 0xd000);
+                 data |= ((stub_entry->orig_insn >> 22) & 0xf) << 8;
+              }
+-           put_thumb_insn (globals, stub_bfd, data, loc + size);
++           bfd_put_16 (stub_bfd, data, loc + size);
+            size += 2;
+          }
+          break;
+ 
+        case THUMB32_TYPE:
+-          put_thumb_insn (globals, stub_bfd,
+-                          (template_sequence[i].data >> 16) & 0xffff,
+-                          loc + size);
+-          put_thumb_insn (globals, stub_bfd, template_sequence[i].data & 0xffff,
+-                          loc + size + 2);
++         bfd_put_16 (stub_bfd,
++                     (template_sequence[i].data >> 16) & 0xffff,
++                     loc + size);
++         bfd_put_16 (stub_bfd, template_sequence[i].data & 0xffff,
++                     loc + size + 2);
+           if (template_sequence[i].r_type != R_ARM_NONE)
+             {
+               stub_reloc_idx[nrelocs] = i;
+@@ -3519,8 +3547,8 @@
+           break;
+ 
+        case ARM_TYPE:
+-         put_arm_insn (globals, stub_bfd, template_sequence[i].data,
+-                        loc + size);
++         bfd_put_32 (stub_bfd, template_sequence[i].data,
++                     loc + size);
+          /* Handle cases where the target is encoded within the
+             instruction.  */
+          if (template_sequence[i].r_type == R_ARM_JUMP24)
+@@ -3599,11 +3627,23 @@
+       }
+     else
+       {
+-       _bfd_final_link_relocate (elf32_arm_howto_from_type
+-           (template_sequence[stub_reloc_idx[i]].r_type), stub_bfd, stub_sec,
+-         stub_sec->contents, stub_entry->stub_offset + stub_reloc_offset[i],
+-         sym_value + stub_entry->target_addend,
+-         template_sequence[stub_reloc_idx[i]].reloc_addend);
++       Elf_Internal_Rela rel;
++       bfd_boolean unresolved_reloc;
++       char *error_message;
++       bfd_vma points_to = sym_value + stub_entry->target_addend
++         + template_sequence[stub_reloc_idx[i]].reloc_addend;
++
++       rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
++       rel.r_info = ELF32_R_INFO (0,
++                                   template_sequence[stub_reloc_idx[i]].r_type);
++       rel.r_addend = 0;
++
++       elf32_arm_final_link_relocate (elf32_arm_howto_from_type
++           (template_sequence[stub_reloc_idx[i]].r_type),
++         stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
++         points_to, info, stub_entry->target_section, "", stub_entry->st_type,
++         (struct elf_link_hash_entry *) stub_entry->h, &unresolved_reloc,
++         &error_message);
+       }
+ 
+   return TRUE;
+@@ -3728,6 +3768,7 @@
+   htab->stub_group = bfd_zmalloc (amt);
+   if (htab->stub_group == NULL)
+     return -1;
++  htab->top_id = top_id;
+ 
+   /* We can't use output_bfd->section_count here to find the top output
+      section index as some sections may have been removed, and
+@@ -4009,7 +4050,7 @@
+                }
+ 
+              is_32bit_branch = is_b || is_bl || is_blx || is_bcc;
+-                          
++
+               if (((base_vma + i) & 0xfff) == 0xffe
+                  && insn_32bit
+                  && is_32bit_branch
+@@ -4178,6 +4219,8 @@
+                           a8_fixes[num_a8_fixes].orig_insn = insn;
+                           a8_fixes[num_a8_fixes].stub_name = stub_name;
+                           a8_fixes[num_a8_fixes].stub_type = stub_type;
++                          a8_fixes[num_a8_fixes].st_type =
++                           is_blx ? STT_FUNC : STT_ARM_TFUNC;
+ 
+                           num_a8_fixes++;
+                         }
+@@ -4193,11 +4236,11 @@
+       if (elf_section_data (section)->this_hdr.contents == NULL)
+         free (contents);
+     }
+-  
++
+   *a8_fixes_p = a8_fixes;
+   *num_a8_fixes_p = num_a8_fixes;
+   *a8_fix_table_size_p = a8_fix_table_size;
+-  
++
+   return FALSE;
+ }
+ 
+@@ -4345,7 +4388,7 @@
+                  const char *sym_name;
+                  char *stub_name;
+                  const asection *id_sec;
+-                 unsigned char st_type;
++                 int st_type;
+                  bfd_boolean created_stub = FALSE;
+ 
+                  r_type = ELF32_R_TYPE (irela->r_info);
+@@ -4403,7 +4446,7 @@
+                        /* This is an undefined symbol.  It can never
+                           be resolved. */
+                        continue;
+-                 
++
+                      if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
+                        sym_value = sym->st_value;
+                      destination = (sym_value + irela->r_addend
+@@ -4493,7 +4536,7 @@
+                    {
+                      /* Determine what (if any) linker stub is needed.  */
+                      stub_type = arm_type_of_stub (info, section, irela,
+-                                                   st_type, hash,
++                                                   &st_type, hash,
+                                                    destination, sym_sec,
+                                                    input_bfd, sym_name);
+                      if (stub_type == arm_stub_none)
+@@ -4504,7 +4547,7 @@
+ 
+                      /* Get the name of this stub.  */
+                      stub_name = elf32_arm_stub_name (id_sec, sym_sec, hash,
+-                                                      irela);
++                                                      irela, stub_type);
+                      if (!stub_name)
+                        goto error_ret_free_internal;
+ 
+@@ -4703,7 +4746,7 @@
+           stub_entry->target_value = a8_fixes[i].offset;
+           stub_entry->target_addend = a8_fixes[i].addend;
+           stub_entry->orig_insn = a8_fixes[i].orig_insn;
+-          stub_entry->st_type = STT_ARM_TFUNC;
++         stub_entry->st_type = a8_fixes[i].st_type;
+ 
+           size = find_stub_size_and_template (a8_fixes[i].stub_type,
+                                               &template_sequence,
+@@ -6866,6 +6909,7 @@
+                          ".tls_vars") == 0)
+          && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
+              || !SYMBOL_CALLS_LOCAL (info, h))
++         && (!strstr (input_section->name, STUB_SUFFIX))
+          && (h == NULL
+              || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+              || h->root.type != bfd_link_hash_undefweak)
+@@ -6990,7 +7034,6 @@
+        case R_ARM_PC24:          /* Arm B/BL instruction.  */
+        case R_ARM_PLT32:
+          {
+-         bfd_signed_vma branch_offset;
+          struct elf32_arm_stub_hash_entry *stub_entry = NULL;
+ 
+          if (r_type == R_ARM_XPC25)
+@@ -7026,45 +7069,46 @@
+              || r_type == R_ARM_JUMP24
+              || r_type == R_ARM_PLT32)
+            {
+-             bfd_vma from;
+-             
+-             /* If the call goes through a PLT entry, make sure to
+-                check distance to the right destination address.  */
+-             if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
+-               {
+-                 value = (splt->output_section->vma
+-                          + splt->output_offset
+-                          + h->plt.offset);
+-                 *unresolved_reloc_p = FALSE;
+-                 /* The PLT entry is in ARM mode, regardless of the
+-                    target function.  */
+-                 sym_flags = STT_FUNC;
+-               }
++             enum elf32_arm_stub_type stub_type = arm_stub_none;
++             struct elf32_arm_link_hash_entry *hash;
+ 
+-             from = (input_section->output_section->vma
+-                     + input_section->output_offset
+-                     + rel->r_offset);
+-             branch_offset = (bfd_signed_vma)(value - from);
+-
+-             if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
+-                 || branch_offset < ARM_MAX_BWD_BRANCH_OFFSET
+-                 || ((sym_flags == STT_ARM_TFUNC)
+-                     && (((r_type == R_ARM_CALL) && !globals->use_blx)
+-                         || (r_type == R_ARM_JUMP24)
+-                         || (r_type == R_ARM_PLT32) ))
+-                 )
++             hash = (struct elf32_arm_link_hash_entry *) h;
++             stub_type = arm_type_of_stub (info, input_section, rel,
++                                           &sym_flags, hash,
++                                           value, sym_sec,
++                                           input_bfd, sym_name);
++
++             if (stub_type != arm_stub_none)
+                {
+                  /* The target is out of reach, so redirect the
+                     branch to the local stub for this function.  */
+ 
+                  stub_entry = elf32_arm_get_stub_entry (input_section,
+                                                         sym_sec, h,
+-                                                        rel, globals);
++                                                        rel, globals,
++                                                        stub_type);
+                  if (stub_entry != NULL)
+                    value = (stub_entry->stub_offset
+                             + stub_entry->stub_sec->output_offset
+                             + stub_entry->stub_sec->output_section->vma);
+                }
++             else
++               {
++                 /* If the call goes through a PLT entry, make sure to
++                    check distance to the right destination address.  */
++                 if (h != NULL
++                     && splt != NULL
++                     && h->plt.offset != (bfd_vma) -1)
++                   {
++                     value = (splt->output_section->vma
++                              + splt->output_offset
++                              + h->plt.offset);
++                     *unresolved_reloc_p = FALSE;
++                     /* The PLT entry is in ARM mode, regardless of the
++                        target function.  */
++                     sym_flags = STT_FUNC;
++                   }
++               }
+            }
+ 
+          /* The ARM ELF ABI says that this reloc is computed as: S - P + A
+@@ -7444,58 +7488,29 @@
+              }
+          }
+ 
+-       /* Handle calls via the PLT.  */
+-       if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
+-         {
+-           value = (splt->output_section->vma
+-                    + splt->output_offset
+-                    + h->plt.offset);
+-           if (globals->use_blx && r_type == R_ARM_THM_CALL)
+-             {
+-               /* If the Thumb BLX instruction is available, convert the
+-                  BL to a BLX instruction to call the ARM-mode PLT entry.  */
+-               lower_insn = (lower_insn & ~0x1000) | 0x0800;
+-               sym_flags = STT_FUNC;
+-             }
+-           else
+-             {
+-               /* Target the Thumb stub before the ARM PLT entry.  */
+-               value -= PLT_THUMB_STUB_SIZE;
+-               sym_flags = STT_ARM_TFUNC;
+-             }
+-           *unresolved_reloc_p = FALSE;
+-         }
+-
++       enum elf32_arm_stub_type stub_type = arm_stub_none;
+        if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
+          {
+            /* Check if a stub has to be inserted because the destination
+               is too far.  */
+-           bfd_vma from;
+-           bfd_signed_vma branch_offset;
+-           struct elf32_arm_stub_hash_entry *stub_entry = NULL;
+-
+-           from = (input_section->output_section->vma
+-                   + input_section->output_offset
+-                   + rel->r_offset);
+-           branch_offset = (bfd_signed_vma)(value - from);
+-
+-           if ((!thumb2
+-                && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
+-                    || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
+-               ||
+-               (thumb2
+-                && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
+-                    || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
+-               || ((sym_flags != STT_ARM_TFUNC)
+-                   && (((r_type == R_ARM_THM_CALL) && !globals->use_blx)
+-                       || r_type == R_ARM_THM_JUMP24)))
++           struct elf32_arm_stub_hash_entry *stub_entry;
++           struct elf32_arm_link_hash_entry *hash;
++
++           hash = (struct elf32_arm_link_hash_entry *) h;
++
++           stub_type = arm_type_of_stub (info, input_section, rel,
++                                         &sym_flags, hash, value, sym_sec,
++                                         input_bfd, sym_name);
++
++           if (stub_type != arm_stub_none)
+              {
+                /* The target is out of reach or we are changing modes, so
+                   redirect the branch to the local stub for this
+                   function.  */
+                stub_entry = elf32_arm_get_stub_entry (input_section,
+                                                       sym_sec, h,
+-                                                      rel, globals);
++                                                      rel, globals,
++                                                      stub_type);
+                if (stub_entry != NULL)
+                  value = (stub_entry->stub_offset
+                           + stub_entry->stub_sec->output_offset
+@@ -7512,6 +7527,33 @@
+              }
+          }
+ 
++       /* Handle calls via the PLT.  */
++       if (stub_type == arm_stub_none
++           && h != NULL
++           && splt != NULL
++           && h->plt.offset != (bfd_vma) -1)
++         {
++           value = (splt->output_section->vma
++                    + splt->output_offset
++                    + h->plt.offset);
++
++           if (globals->use_blx && r_type == R_ARM_THM_CALL)
++             {
++               /* If the Thumb BLX instruction is available, convert
++                  the BL to a BLX instruction to call the ARM-mode
++                  PLT entry.  */
++               lower_insn = (lower_insn & ~0x1000) | 0x0800;
++               sym_flags = STT_FUNC;
++             }
++           else
++             {
++               /* Target the Thumb stub before the ARM PLT entry.  */
++               value -= PLT_THUMB_STUB_SIZE;
++               sym_flags = STT_ARM_TFUNC;
++             }
++           *unresolved_reloc_p = FALSE;
++         }
++
+        relocation = value + signed_addend;
+ 
+        relocation -= (input_section->output_section->vma
+@@ -9298,11 +9340,26 @@
+ elf32_arm_final_link (bfd *abfd, struct bfd_link_info *info)
+ {
+   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info);
++  asection *sec, *osec;
+ 
+   /* Invoke the regular ELF backend linker to do all the work.  */
+   if (!bfd_elf_final_link (abfd, info))
+     return FALSE;
+ 
++  /* Process stub sections (eg BE8 encoding, ...).  */
++  struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
++  int i;
++  for(i=0; i<htab->top_id; i++) {
++    sec = htab->stub_group[i].stub_sec;
++    if (sec) {
++      osec = sec->output_section;
++      elf32_arm_write_section (abfd, info, sec, sec->contents);
++      if (! bfd_set_section_contents (abfd, osec, sec->contents,
++                                     sec->output_offset, sec->size))
++       return FALSE;
++    }
++  }
++
+   /* Write out any glue sections now that we have created all the
+      stubs.  */
+   if (globals->bfd_of_glue_owner != NULL)
+@@ -12875,6 +12932,7 @@
+   sym.st_other = 0;
+   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
+   sym.st_shndx = osi->sec_shndx;
++  elf32_arm_section_map_add (osi->sec, names[type][1], offset);
+   return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
+ }
+