obsolete-buildroot/sources/binutils-uclibc-001-debian.patch

   1 diff -urN binutils-2.14.90.0.7.orig/bfd/ChangeLog binutils-2.14.90.0.7/bfd/ChangeLog
   2 --- binutils-2.14.90.0.7.orig/bfd/ChangeLog     2003-10-29 10:37:47.000000000 -0700
   3 +++ binutils-2.14.90.0.7/bfd/ChangeLog  2004-04-20 01:26:12.000000000 -0600
   4 @@ -1,3 +1,34 @@
   5 +2003-10-29  Daniel Jacobowitz  <drow@mvista.com>
   6 +
   7 +        * elf32-arm.h (elf32_arm_final_link_relocate): Move check for
   8 +        SEC_ALLOC.
   9 +
  10 +2003-10-29  Philip Blundell  <philb@gnu.org>
  11 +
  12 +       * elf32-arm.h (elf32_arm_plt0_entry, elf32_arm_plt_entry): New
  13 +       code sequence.
  14 +       (PLT_HEADER_SIZE): New.
  15 +       (struct elf32_arm_pcrel_relocs_copied): Rename to ...
  16 +       (struct elf32_arm_relocs_copied): ... this.  Count both
  17 +       pcrel and non-pcrel relocs.  All uses updated.
  18 +       (struct elf32_arm_link_hash_table): Add pointers to dynamic linker
  19 +       sections and symbol/section mapping cache.
  20 +       (create_got_section): New.
  21 +       (elf32_arm_create_dynamic_sections): New.
  22 +       (elf_backend_create_dynamic_sections): Use it.
  23 +       (elf32_arm_final_link_relocate): Support garbage collection of relocs.
  24 +       (elf32_arm_check_relocs): Likewise.
  25 +       (elf32_arm_adjust_dynamic_symbol): Likewise.
  26 +       (elf32_arm_copy_indirect_symbol): New.
  27 +       (elf32_arm_link_hash_table_create): Initialise new fields.
  28 +       (elf32_arm_gc_sweep_hook): Implement.
  29 +       (elf32_arm_discard_copies): Delete.
  30 +       (elf32_arm_finish_dynamic_symbol): Use new PLT code.
  31 +       (elf32_arm_finish_dynamic_sections): Likewise.
  32 +       (elf_backend_can_refcount): Define.
  33 +       (elf_backend_copy_indirect_symbol): Likewise.
  34 +       (elf_backend_plt_header_size): Set to PLT_HEADER_SIZE.
  35 +
  36  2003-10-29  Alan Modra  <amodra@bigpond.net.au>
  37
  38         * elf64-ppc.c (elf_backend_grok_prstatus): Define.
  39 diff -urN binutils-2.14.90.0.7.orig/bfd/elf-bfd.h binutils-2.14.90.0.7/bfd/elf-bfd.h
  40 --- binutils-2.14.90.0.7.orig/bfd/elf-bfd.h     2003-10-29 10:37:47.000000000 -0700
  41 +++ binutils-2.14.90.0.7/bfd/elf-bfd.h  2004-04-20 01:26:12.000000000 -0600
  42 @@ -1303,7 +1303,7 @@
  43  extern enum elf_reloc_type_class _bfd_elf_reloc_type_class
  44    (const Elf_Internal_Rela *);
  45  extern bfd_vma _bfd_elf_rela_local_sym
  46 -  (bfd *, Elf_Internal_Sym *, asection *, Elf_Internal_Rela *);
  47 +  (bfd *, Elf_Internal_Sym *, asection **, Elf_Internal_Rela *);
  48  extern bfd_vma _bfd_elf_rel_local_sym
  49    (bfd *, Elf_Internal_Sym *, asection **, bfd_vma);
  50  extern bfd_vma _bfd_elf_section_offset
  51 diff -urN binutils-2.14.90.0.7.orig/bfd/elf-hppa.h binutils-2.14.90.0.7/bfd/elf-hppa.h
  52 --- binutils-2.14.90.0.7.orig/bfd/elf-hppa.h    2003-08-21 09:28:47.000000000 -0600
  53 +++ binutils-2.14.90.0.7/bfd/elf-hppa.h 2004-04-20 01:26:12.000000000 -0600
  54 @@ -1346,11 +1346,11 @@
  55           /* This is a local symbol.  */
  56           sym = local_syms + r_symndx;
  57           sym_sec = local_sections[r_symndx];
  58 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
  59 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
  60
  61           /* If this symbol has an entry in the PA64 dynamic hash
  62              table, then get it.  */
  63 -         dyn_name = get_dyn_name (input_section, h, rel,
  64 +         dyn_name = get_dyn_name (input_bfd, h, rel,
  65                                    &dynh_buf, &dynh_buflen);
  66           dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
  67                                               dyn_name, FALSE, FALSE);
  68 @@ -1373,7 +1373,7 @@
  69
  70               /* If this symbol has an entry in the PA64 dynamic hash
  71                  table, then get it.  */
  72 -             dyn_name = get_dyn_name (input_section, h, rel,
  73 +             dyn_name = get_dyn_name (input_bfd, h, rel,
  74                                        &dynh_buf, &dynh_buflen);
  75               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
  76                                                   dyn_name, FALSE, FALSE);
  77 @@ -1410,7 +1410,7 @@
  78
  79               /* If this symbol has an entry in the PA64 dynamic hash
  80                  table, then get it.  */
  81 -             dyn_name = get_dyn_name (input_section, h, rel,
  82 +             dyn_name = get_dyn_name (input_bfd, h, rel,
  83                                        &dynh_buf, &dynh_buflen);
  84               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
  85                                                   dyn_name, FALSE, FALSE);
  86 @@ -1426,7 +1426,7 @@
  87             }
  88           else if (h->root.type == bfd_link_hash_undefweak)
  89              {
  90 -             dyn_name = get_dyn_name (input_section, h, rel,
  91 +             dyn_name = get_dyn_name (input_bfd, h, rel,
  92                                        &dynh_buf, &dynh_buflen);
  93               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
  94                                                   dyn_name, FALSE, FALSE);
  95 diff -urN binutils-2.14.90.0.7.orig/bfd/elf-m10200.c binutils-2.14.90.0.7/bfd/elf-m10200.c
  96 --- binutils-2.14.90.0.7.orig/bfd/elf-m10200.c  2003-07-23 09:08:08.000000000 -0600
  97 +++ binutils-2.14.90.0.7/bfd/elf-m10200.c       2004-04-20 01:26:12.000000000 -0600
  98 @@ -373,7 +373,7 @@
  99         {
 100           sym = local_syms + r_symndx;
 101           sec = local_sections[r_symndx];
 102 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
 103 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 104         }
 105        else
 106         {
 107 diff -urN binutils-2.14.90.0.7.orig/bfd/elf-m10300.c binutils-2.14.90.0.7/bfd/elf-m10300.c
 108 --- binutils-2.14.90.0.7.orig/bfd/elf-m10300.c  2003-08-21 09:28:47.000000000 -0600
 109 +++ binutils-2.14.90.0.7/bfd/elf-m10300.c       2004-04-20 01:26:12.000000000 -0600
 110 @@ -1574,7 +1574,7 @@
 111         {
 112           sym = local_syms + r_symndx;
 113           sec = local_sections[r_symndx];
 114 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
 115 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 116         }
 117        else
 118         {
 119 diff -urN binutils-2.14.90.0.7.orig/bfd/elf.c binutils-2.14.90.0.7/bfd/elf.c
 120 --- binutils-2.14.90.0.7.orig/bfd/elf.c 2003-10-29 10:37:47.000000000 -0700
 121 +++ binutils-2.14.90.0.7/bfd/elf.c      2004-04-20 01:26:12.000000000 -0600
 122 @@ -7367,9 +7367,10 @@
 123  bfd_vma
 124  _bfd_elf_rela_local_sym (bfd *abfd,
 125                          Elf_Internal_Sym *sym,
 126 -                        asection *sec,
 127 +                        asection **psec,
 128                          Elf_Internal_Rela *rel)
 129  {
 130 +  asection *sec = *psec;
 131    bfd_vma relocation;
 132
 133    relocation = (sec->output_section->vma
 134 @@ -7379,16 +7380,14 @@
 135        && ELF_ST_TYPE (sym->st_info) == STT_SECTION
 136        && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
 137      {
 138 -      asection *msec;
 139 -
 140 -      msec = sec;
 141        rel->r_addend =
 142 -       _bfd_merged_section_offset (abfd, &msec,
 143 +       _bfd_merged_section_offset (abfd, psec,
 144                                     elf_section_data (sec)->sec_info,
 145                                     sym->st_value + rel->r_addend,
 146 -                                   0)
 147 -       - relocation;
 148 -      rel->r_addend += msec->output_section->vma + msec->output_offset;
 149 +                                   0);
 150 +      sec = *psec;
 151 +      rel->r_addend -= relocation;
 152 +      rel->r_addend += sec->output_section->vma + sec->output_offset;
 153      }
 154    return relocation;
 155  }
 156 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-arm.h binutils-2.14.90.0.7/bfd/elf32-arm.h
 157 --- binutils-2.14.90.0.7.orig/bfd/elf32-arm.h   2003-10-29 10:37:47.000000000 -0700
 158 +++ binutils-2.14.90.0.7/bfd/elf32-arm.h        2004-04-20 01:26:12.000000000 -0600
 159 @@ -84,6 +84,12 @@
 160  static void arm_add_to_rel
 161    PARAMS ((bfd *, bfd_byte *, reloc_howto_type *, bfd_signed_vma));
 162  #endif
 163 +static bfd_boolean allocate_dynrelocs
 164 +  PARAMS ((struct elf_link_hash_entry *h, PTR inf));
 165 +static bfd_boolean create_got_section
 166 +  PARAMS ((bfd * dynobj, struct bfd_link_info * info));
 167 +static bfd_boolean elf32_arm_create_dynamic_sections
 168 +  PARAMS ((bfd * dynobj, struct bfd_link_info * info));
 169  static enum elf_reloc_type_class elf32_arm_reloc_type_class
 170    PARAMS ((const Elf_Internal_Rela *));
 171  static bfd_boolean elf32_arm_object_p
 172 @@ -119,6 +125,12 @@
 173     section.  */
 174  #define ELF_DYNAMIC_INTERPRETER     "/usr/lib/ld.so.1"
 175
 176 +#ifdef FOUR_WORD_PLT
 177 +
 178 +/* The size in bytes of the special first entry in the procedure
 179 +   linkage table.  */
 180 +#define PLT_HEADER_SIZE 16
 181 +
 182  /* The size in bytes of an entry in the procedure linkage table.  */
 183  #define PLT_ENTRY_SIZE 16
 184
 185 @@ -126,23 +138,56 @@
 186     this.  It is set up so that any shared library function that is
 187     called before the relocation has been set up calls the dynamic
 188     linker first.  */
 189 -static const bfd_vma elf32_arm_plt0_entry [PLT_ENTRY_SIZE / 4] =
 190 +static const bfd_vma elf32_arm_plt0_entry [PLT_HEADER_SIZE / 4] =
 191    {
 192 -    0xe52de004,        /* str   lr, [sp, #-4]!     */
 193 -    0xe59fe010,        /* ldr   lr, [pc, #16]      */
 194 -    0xe08fe00e,        /* add   lr, pc, lr         */
 195 -    0xe5bef008 /* ldr   pc, [lr, #8]!      */
 196 +    0xe52de004,                /* str   lr, [sp, #-4]! */
 197 +    0xe59fe010,                /* ldr   lr, [pc, #16]  */
 198 +    0xe08fe00e,                /* add   lr, pc, lr     */
 199 +    0xe5bef008,                /* ldr   pc, [lr, #8]!  */
 200    };
 201
 202  /* Subsequent entries in a procedure linkage table look like
 203     this.  */
 204  static const bfd_vma elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
 205 - {
 206 -   0xe59fc004, /* ldr   ip, [pc, #4]       */
 207 -   0xe08fc00c, /* add   ip, pc, ip         */
 208 -   0xe59cf000, /* ldr   pc, [ip]           */
 209 -   0x00000000  /* offset to symbol in got  */
 210 - };
 211 +  {
 212 +    0xe28fc600,                /* add   ip, pc, #NN    */
 213 +    0xe28cca00,                /* add   ip, ip, #NN    */
 214 +    0xe5bcf000,                /* ldr   pc, [ip, #NN]! */
 215 +    0x00000000,                /* unused               */
 216 +  };
 217 +
 218 +#else
 219 +
 220 +/* The size in bytes of the special first entry in the procedure
 221 +   linkage table.  */
 222 +#define PLT_HEADER_SIZE 20
 223 +
 224 +/* The size in bytes of an entry in the procedure linkage table.  */
 225 +#define PLT_ENTRY_SIZE 12
 226 +
 227 +/* The first entry in a procedure linkage table looks like
 228 +   this.  It is set up so that any shared library function that is
 229 +   called before the relocation has been set up calls the dynamic
 230 +   linker first.  */
 231 +static const bfd_vma elf32_arm_plt0_entry [PLT_HEADER_SIZE / 4] =
 232 +  {
 233 +    0xe52de004,                /* str   lr, [sp, #-4]! */
 234 +    0xe59fe004,                /* ldr   lr, [pc, #4]   */
 235 +    0xe08fe00e,                /* add   lr, pc, lr     */
 236 +    0xe5bef008,                /* ldr   pc, [lr, #8]!  */
 237 +    0x00000000,                /* &GOT[0] - .          */
 238 +  };
 239 +
 240 +/* Subsequent entries in a procedure linkage table look like
 241 +   this.  */
 242 +static const bfd_vma elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
 243 +  {
 244 +    0xe28fc600,                /* add   ip, pc, #0xNN00000 */
 245 +    0xe28cca00,                /* add   ip, ip, #0xNN000   */
 246 +    0xe5bcf000,                /* ldr   pc, [ip, #0xNNN]!  */
 247 +  };
 248 +
 249 +#endif
 250
 251  /* The ARM linker needs to keep track of the number of relocs that it
 252     decides to copy in check_relocs for each symbol.  This is so that
 253 @@ -152,14 +197,16 @@
 254
 255  /* This structure keeps track of the number of PC relative relocs we
 256     have copied for a given symbol.  */
 257 -struct elf32_arm_pcrel_relocs_copied
 258 +struct elf32_arm_relocs_copied
 259    {
 260      /* Next section.  */
 261 -    struct elf32_arm_pcrel_relocs_copied * next;
 262 +    struct elf32_arm_relocs_copied * next;
 263      /* A section in dynobj.  */
 264      asection * section;
 265      /* Number of relocs copied in this section.  */
 266      bfd_size_type count;
 267 +    /* Number of relocs copied in this section.  */
 268 +    bfd_size_type pc_count;
 269    };
 270
 271  /* Arm ELF linker hash entry.  */
 272 @@ -168,13 +215,9 @@
 273      struct elf_link_hash_entry root;
 274
 275      /* Number of PC relative relocs copied for this symbol.  */
 276 -    struct elf32_arm_pcrel_relocs_copied * pcrel_relocs_copied;
 277 +    struct elf32_arm_relocs_copied * relocs_copied;
 278    };
 279
 280 -/* Declare this now that the above structures are defined.  */
 281 -static bfd_boolean elf32_arm_discard_copies
 282 -  PARAMS ((struct elf32_arm_link_hash_entry *, PTR));
 283 -
 284  /* Traverse an arm ELF linker hash table.  */
 285  #define elf32_arm_link_hash_traverse(table, func, info)                        \
 286    (elf_link_hash_traverse                                              \
 287 @@ -204,6 +247,18 @@
 288      /* A boolean indicating whether knowledge of the ARM's pipeline
 289         length should be applied by the linker.  */
 290      int no_pipeline_knowledge;
 291 +
 292 +    /* Short-cuts to get to dynamic linker sections.  */
 293 +    asection *sgot;
 294 +    asection *sgotplt;
 295 +    asection *srelgot;
 296 +    asection *splt;
 297 +    asection *srelplt;
 298 +    asection *sdynbss;
 299 +    asection *srelbss;
 300 +
 301 +    /* Small local sym to section mapping cache.  */
 302 +    struct sym_sec_cache sym_sec;
 303    };
 304
 305  /* Create an entry in an ARM ELF linker hash table.  */
 306 @@ -231,11 +286,121 @@
 307          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 308                                      table, string));
 309    if (ret != (struct elf32_arm_link_hash_entry *) NULL)
 310 -    ret->pcrel_relocs_copied = NULL;
 311 +    ret->relocs_copied = NULL;
 312
 313    return (struct bfd_hash_entry *) ret;
 314  }
 315
 316 +/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
 317 +   shortcuts to them in our hash table.  */
 318 +
 319 +static bfd_boolean
 320 +create_got_section (dynobj, info)
 321 +     bfd *dynobj;
 322 +     struct bfd_link_info *info;
 323 +{
 324 +  struct elf32_arm_link_hash_table *htab;
 325 +
 326 +  if (! _bfd_elf_create_got_section (dynobj, info))
 327 +    return FALSE;
 328 +
 329 +  htab = elf32_arm_hash_table (info);
 330 +  htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 331 +  htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 332 +  if (!htab->sgot || !htab->sgotplt)
 333 +    abort ();
 334 +
 335 +  htab->srelgot = bfd_make_section (dynobj, ".rel.got");
 336 +  if (htab->srelgot == NULL
 337 +      || ! bfd_set_section_flags (dynobj, htab->srelgot,
 338 +                                 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 339 +                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED
 340 +                                  | SEC_READONLY))
 341 +      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 342 +    return FALSE;
 343 +  return TRUE;
 344 +}
 345 +
 346 +/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
 347 +   .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
 348 +   hash table.  */
 349 +
 350 +static bfd_boolean
 351 +elf32_arm_create_dynamic_sections (dynobj, info)
 352 +     bfd *dynobj;
 353 +     struct bfd_link_info *info;
 354 +{
 355 +  struct elf32_arm_link_hash_table *htab;
 356 +
 357 +  htab = elf32_arm_hash_table (info);
 358 +  if (!htab->sgot && !create_got_section (dynobj, info))
 359 +    return FALSE;
 360 +
 361 +  if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 362 +    return FALSE;
 363 +
 364 +  htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 365 +  htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
 366 +  htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 367 +  if (!info->shared)
 368 +    htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
 369 +
 370 +  if (!htab->splt || !htab->srelplt || !htab->sdynbss
 371 +      || (!info->shared && !htab->srelbss))
 372 +    abort ();
 373 +
 374 +  return TRUE;
 375 +}
 376 +
 377 +/* Copy the extra info we tack onto an elf_link_hash_entry.  */
 378 +
 379 +static void
 380 +elf32_arm_copy_indirect_symbol (const struct elf_backend_data *bed,
 381 +                               struct elf_link_hash_entry *dir,
 382 +                               struct elf_link_hash_entry *ind)
 383 +{
 384 +  struct elf32_arm_link_hash_entry *edir, *eind;
 385 +
 386 +  edir = (struct elf32_arm_link_hash_entry *) dir;
 387 +  eind = (struct elf32_arm_link_hash_entry *) ind;
 388 +
 389 +  if (eind->relocs_copied != NULL)
 390 +    {
 391 +      if (edir->relocs_copied != NULL)
 392 +       {
 393 +         struct elf32_arm_relocs_copied **pp;
 394 +         struct elf32_arm_relocs_copied *p;
 395 +
 396 +         if (ind->root.type == bfd_link_hash_indirect)
 397 +           abort ();
 398 +
 399 +         /* Add reloc counts against the weak sym to the strong sym
 400 +            list.  Merge any entries against the same section.  */
 401 +         for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
 402 +           {
 403 +             struct elf32_arm_relocs_copied *q;
 404 +
 405 +             for (q = edir->relocs_copied; q != NULL; q = q->next)
 406 +               if (q->section == p->section)
 407 +                 {
 408 +                   q->pc_count += p->pc_count;
 409 +                   q->count += p->count;
 410 +                   *pp = p->next;
 411 +                   break;
 412 +                 }
 413 +             if (q == NULL)
 414 +               pp = &p->next;
 415 +           }
 416 +         *pp = edir->relocs_copied;
 417 +       }
 418 +
 419 +      edir->relocs_copied = eind->relocs_copied;
 420 +      eind->relocs_copied = NULL;
 421 +    }
 422 +
 423 +  _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 424 +}
 425 +
 426  /* Create an ARM elf linker hash table.  */
 427
 428  static struct bfd_link_hash_table *
 429 @@ -256,10 +421,18 @@
 430        return NULL;
 431      }
 432
 433 +  ret->sgot = NULL;
 434 +  ret->sgotplt = NULL;
 435 +  ret->srelgot = NULL;
 436 +  ret->splt = NULL;
 437 +  ret->srelplt = NULL;
 438 +  ret->sdynbss = NULL;
 439 +  ret->srelbss = NULL;
 440    ret->thumb_glue_size = 0;
 441    ret->arm_glue_size = 0;
 442    ret->bfd_of_glue_owner = NULL;
 443    ret->no_pipeline_knowledge = 0;
 444 +  ret->sym_sec.abfd = NULL;
 445
 446    return &ret->root.root;
 447  }
 448 @@ -1134,16 +1307,21 @@
 449  #ifndef OLD_ARM_ABI
 450      case R_ARM_XPC25:
 451  #endif
 452 +      /* r_symndx will be zero only for relocs against symbols
 453 +        from removed linkonce sections, or sections discarded by
 454 +        a linker script.  */
 455 +      if (r_symndx == 0)
 456 +       return bfd_reloc_ok;
 457 +
 458        /* When generating a shared object, these relocations are copied
 459          into the output file to be resolved at run time.  */
 460 -      if (info->shared
 461 -         && r_symndx != 0
 462 -         && (r_type != R_ARM_PC24
 463 -             || (h != NULL
 464 -                 && h->dynindx != -1
 465 -                 && (! info->symbolic
 466 -                     || (h->elf_link_hash_flags
 467 -                         & ELF_LINK_HASH_DEF_REGULAR) == 0))))
 468 +      if ((info->shared
 469 +          && (input_section->flags & SEC_ALLOC)
 470 +          && (h == NULL
 471 +              || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
 472 +              || h->root.type != bfd_link_hash_undefweak)
 473 +          && (r_type != R_ARM_PC24
 474 +              || !SYMBOL_CALLS_LOCAL (info, h))))
 475         {
 476           Elf_Internal_Rela outrel;
 477           bfd_byte *loc;
 478 @@ -1184,30 +1362,19 @@
 479
 480           if (skip)
 481             memset (&outrel, 0, sizeof outrel);
 482 -         else if (r_type == R_ARM_PC24)
 483 -           {
 484 -             BFD_ASSERT (h != NULL && h->dynindx != -1);
 485 -             if ((input_section->flags & SEC_ALLOC) == 0)
 486 -               relocate = TRUE;
 487 -             outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
 488 -           }
 489 +         else if (h != NULL
 490 +                  && h->dynindx != -1
 491 +                  && (r_type == R_ARM_PC24
 492 +                      || !info->shared
 493 +                      || !info->symbolic
 494 +                      || (h->elf_link_hash_flags
 495 +                          & ELF_LINK_HASH_DEF_REGULAR) == 0))
 496 +           outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
 497           else
 498             {
 499 -             if (h == NULL
 500 -                 || ((info->symbolic || h->dynindx == -1)
 501 -                     && (h->elf_link_hash_flags
 502 -                         & ELF_LINK_HASH_DEF_REGULAR) != 0))
 503 -               {
 504 -                 relocate = TRUE;
 505 -                 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
 506 -               }
 507 -             else
 508 -               {
 509 -                 BFD_ASSERT (h->dynindx != -1);
 510 -                 if ((input_section->flags & SEC_ALLOC) == 0)
 511 -                   relocate = TRUE;
 512 -                 outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
 513 -               }
 514 +             /* This symbol is local, or marked to become local.  */
 515 +             relocate = TRUE;
 516 +             outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
 517             }
 518
 519           loc = sreloc->contents;
 520 @@ -1617,16 +1784,17 @@
 521        if (h != NULL)
 522         {
 523           bfd_vma off;
 524 -         bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
 525 +         bfd_boolean dyn;
 526
 527           off = h->got.offset;
 528           BFD_ASSERT (off != (bfd_vma) -1);
 529 +         dyn = globals->root.dynamic_sections_created;
 530
 531 -         if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
 532 +         if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
 533               || (info->shared
 534 -                 && (info->symbolic || h->dynindx == -1
 535 -                     || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
 536 -                 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
 537 +                 && SYMBOL_REFERENCES_LOCAL (info, h))
 538 +             || (ELF_ST_VISIBILITY (h->other)
 539 +                 && h->root.type == bfd_link_hash_undefweak))
 540             {
 541               /* This is actually a static link, or it is a -Bsymbolic link
 542                  and the symbol is defined locally.  We must initialize this
 543 @@ -1712,7 +1880,8 @@
 544                                  contents, rel->r_offset, value,
 545                                  (bfd_vma) 0);
 546
 547 -      if (h->plt.offset == (bfd_vma) -1)
 548 +      if (h->plt.offset == (bfd_vma) -1
 549 +         || globals->splt == NULL)
 550          /* We didn't make a PLT entry for this symbol.  This
 551             happens when statically linking PIC code, or when
 552             using -Bsymbolic.  */
 553 @@ -1958,7 +2127,7 @@
 554               bfd_put_32 (input_bfd, value, contents + rel->r_offset);
 555             }
 556  #else
 557 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
 558 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 559  #endif
 560         }
 561        else
 562 @@ -1983,9 +2152,10 @@
 563                 case R_ARM_THM_PC22:
 564                   if (info->shared
 565                       && (
 566 -                 (!info->symbolic && h->dynindx != -1)
 567 +                         (!info->symbolic && h->dynindx != -1)
 568                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
 569                           )
 570 +                     && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
 571                       && ((input_section->flags & SEC_ALLOC) != 0
 572                           /* DWARF will emit R_ARM_ABS32 relocations in its
 573                              sections against symbols defined externally
 574 @@ -2603,7 +2773,82 @@
 575       asection *sec ATTRIBUTE_UNUSED;
 576       const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
 577  {
 578 -  /* We don't support garbage collection of GOT and PLT relocs yet.  */
 579 +  Elf_Internal_Shdr *symtab_hdr;
 580 +  struct elf_link_hash_entry **sym_hashes;
 581 +  bfd_signed_vma *local_got_refcounts;
 582 +  const Elf_Internal_Rela *rel, *relend;
 583 +  unsigned long r_symndx;
 584 +  struct elf_link_hash_entry *h;
 585 +
 586 +  elf_section_data (sec)->local_dynrel = NULL;
 587 +
 588 +  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 589 +  sym_hashes = elf_sym_hashes (abfd);
 590 +  local_got_refcounts = elf_local_got_refcounts (abfd);
 591 +
 592 +  relend = relocs + sec->reloc_count;
 593 +  for (rel = relocs; rel < relend; rel++)
 594 +    switch (ELF32_R_TYPE (rel->r_info))
 595 +      {
 596 +      case R_ARM_GOT32:
 597 +       r_symndx = ELF32_R_SYM (rel->r_info);
 598 +       if (r_symndx >= symtab_hdr->sh_info)
 599 +         {
 600 +           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 601 +           if (h->got.refcount > 0)
 602 +             h->got.refcount -= 1;
 603 +         }
 604 +       else if (local_got_refcounts != NULL)
 605 +         {
 606 +           if (local_got_refcounts[r_symndx] > 0)
 607 +             local_got_refcounts[r_symndx] -= 1;
 608 +         }
 609 +       break;
 610 +
 611 +      case R_ARM_ABS32:
 612 +      case R_ARM_REL32:
 613 +      case R_ARM_PC24:
 614 +       r_symndx = ELF32_R_SYM (rel->r_info);
 615 +       if (r_symndx >= symtab_hdr->sh_info)
 616 +         {
 617 +           struct elf32_arm_link_hash_entry *eh;
 618 +           struct elf32_arm_relocs_copied **pp;
 619 +           struct elf32_arm_relocs_copied *p;
 620 +
 621 +           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 622 +
 623 +           if (!info->shared && h->plt.refcount > 0)
 624 +             h->plt.refcount -= 1;
 625 +
 626 +           eh = (struct elf32_arm_link_hash_entry *) h;
 627 +
 628 +           for (pp = &eh->relocs_copied; (p = *pp) != NULL; pp = &p->next)
 629 +             if (p->section == sec)
 630 +               {
 631 +                 if (ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
 632 +                   p->pc_count -= 1;
 633 +                 p->count -= 1;
 634 +                 if (p->count == 0)
 635 +                   *pp = p->next;
 636 +                 break;
 637 +               }
 638 +         }
 639 +       break;
 640 +
 641 +      case R_ARM_PLT32:
 642 +       r_symndx = ELF32_R_SYM (rel->r_info);
 643 +       if (r_symndx >= symtab_hdr->sh_info)
 644 +         {
 645 +           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 646 +           if (h->plt.refcount > 0)
 647 +             h->plt.refcount -= 1;
 648 +         }
 649 +       break;
 650 +
 651 +      default:
 652 +       break;
 653 +      }
 654 +
 655    return TRUE;
 656  }
 657
 658 @@ -2622,13 +2867,15 @@
 659    const Elf_Internal_Rela *rel;
 660    const Elf_Internal_Rela *rel_end;
 661    bfd *dynobj;
 662 -  asection *sgot, *srelgot, *sreloc;
 663 +  asection *sreloc;
 664    bfd_vma *local_got_offsets;
 665 +  struct elf32_arm_link_hash_table *htab;
 666
 667    if (info->relocatable)
 668      return TRUE;
 669
 670 -  sgot = srelgot = sreloc = NULL;
 671 +  htab = elf32_arm_hash_table (info);
 672 +  sreloc = NULL;
 673
 674    dynobj = elf_hash_table (info)->dynobj;
 675    local_got_offsets = elf_local_got_offsets (abfd);
 676 @@ -2653,126 +2900,82 @@
 677        else
 678          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 679
 680 -      /* Some relocs require a global offset table.  */
 681 -      if (dynobj == NULL)
 682 -       {
 683 -         switch (ELF32_R_TYPE (rel->r_info))
 684 -           {
 685 -           case R_ARM_GOT32:
 686 -           case R_ARM_GOTOFF:
 687 -           case R_ARM_GOTPC:
 688 -             elf_hash_table (info)->dynobj = dynobj = abfd;
 689 -             if (! _bfd_elf_create_got_section (dynobj, info))
 690 -               return FALSE;
 691 -             break;
 692 -
 693 -           default:
 694 -             break;
 695 -           }
 696 -       }
 697 -
 698        switch (ELF32_R_TYPE (rel->r_info))
 699          {
 700 -         case R_ARM_GOT32:
 701 -           /* This symbol requires a global offset table entry.  */
 702 -           if (sgot == NULL)
 703 -             {
 704 -               sgot = bfd_get_section_by_name (dynobj, ".got");
 705 -               BFD_ASSERT (sgot != NULL);
 706 -             }
 707 +         case R_ARM_PLT32:
 708 +           /* This symbol requires a procedure linkage table entry.  We
 709 +               actually build the entry in adjust_dynamic_symbol,
 710 +               because this might be a case of linking PIC code which is
 711 +               never referenced by a dynamic object, in which case we
 712 +               don't need to generate a procedure linkage table entry
 713 +               after all.  */
 714
 715 -           /* Get the got relocation section if necessary.  */
 716 -           if (srelgot == NULL
 717 -               && (h != NULL || info->shared))
 718 -             {
 719 -               srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
 720 +           /* If this is a local symbol, we resolve it directly without
 721 +               creating a procedure linkage table entry.  */
 722 +           if (h == NULL)
 723 +             continue;
 724
 725 -               /* If no got relocation section, make one and initialize.  */
 726 -               if (srelgot == NULL)
 727 -                 {
 728 -                   srelgot = bfd_make_section (dynobj, ".rel.got");
 729 -                   if (srelgot == NULL
 730 -                       || ! bfd_set_section_flags (dynobj, srelgot,
 731 -                                                   (SEC_ALLOC
 732 -                                                    | SEC_LOAD
 733 -                                                    | SEC_HAS_CONTENTS
 734 -                                                    | SEC_IN_MEMORY
 735 -                                                    | SEC_LINKER_CREATED
 736 -                                                    | SEC_READONLY))
 737 -                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
 738 -                     return FALSE;
 739 -                 }
 740 -             }
 741 +           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 742 +           h->plt.refcount++;
 743 +           break;
 744
 745 +         case R_ARM_GOT32:
 746 +           /* This symbol requires a global offset table entry.  */
 747             if (h != NULL)
 748               {
 749 -               if (h->got.offset != (bfd_vma) -1)
 750 -                 /* We have already allocated space in the .got.  */
 751 -                 break;
 752 -
 753 -               h->got.offset = sgot->_raw_size;
 754 -
 755 -               /* Make sure this symbol is output as a dynamic symbol.  */
 756 -               if (h->dynindx == -1)
 757 -                 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 758 -                   return FALSE;
 759 -
 760 -               srelgot->_raw_size += sizeof (Elf32_External_Rel);
 761 +               h->got.refcount++;
 762               }
 763             else
 764               {
 765 -               /* This is a global offset table entry for a local
 766 -                   symbol.  */
 767 -               if (local_got_offsets == NULL)
 768 +               bfd_signed_vma *local_got_refcounts;
 769 +
 770 +               /* This is a global offset table entry for a local symbol.  */
 771 +               local_got_refcounts = elf_local_got_refcounts (abfd);
 772 +               if (local_got_refcounts == NULL)
 773                   {
 774                     bfd_size_type size;
 775 -                   unsigned int i;
 776
 777                     size = symtab_hdr->sh_info;
 778 -                   size *= sizeof (bfd_vma);
 779 -                   local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
 780 -                   if (local_got_offsets == NULL)
 781 +                   size *= (sizeof (bfd_signed_vma) + sizeof(char));
 782 +                   local_got_refcounts = ((bfd_signed_vma *)
 783 +                                          bfd_zalloc (abfd, size));
 784 +                   if (local_got_refcounts == NULL)
 785                       return FALSE;
 786 -                   elf_local_got_offsets (abfd) = local_got_offsets;
 787 -                   for (i = 0; i < symtab_hdr->sh_info; i++)
 788 -                     local_got_offsets[i] = (bfd_vma) -1;
 789 +                   elf_local_got_refcounts (abfd) = local_got_refcounts;
 790                   }
 791 -
 792 -               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
 793 -                 /* We have already allocated space in the .got.  */
 794 -                 break;
 795 -
 796 -               local_got_offsets[r_symndx] = sgot->_raw_size;
 797 -
 798 -               if (info->shared)
 799 -                 /* If we are generating a shared object, we need to
 800 -                    output a R_ARM_RELATIVE reloc so that the dynamic
 801 -                    linker can adjust this GOT entry.  */
 802 -                 srelgot->_raw_size += sizeof (Elf32_External_Rel);
 803 +               local_got_refcounts[r_symndx] += 1;
 804               }
 805 -
 806 -           sgot->_raw_size += 4;
 807             break;
 808
 809 -         case R_ARM_PLT32:
 810 -           /* This symbol requires a procedure linkage table entry.  We
 811 -               actually build the entry in adjust_dynamic_symbol,
 812 -               because this might be a case of linking PIC code which is
 813 -               never referenced by a dynamic object, in which case we
 814 -               don't need to generate a procedure linkage table entry
 815 -               after all.  */
 816 -
 817 -           /* If this is a local symbol, we resolve it directly without
 818 -               creating a procedure linkage table entry.  */
 819 -           if (h == NULL)
 820 -             continue;
 821 -
 822 -           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 823 +         case R_ARM_GOTOFF:
 824 +         case R_ARM_GOTPC:
 825 +           if (htab->sgot == NULL)
 826 +             {
 827 +               if (htab->root.dynobj == NULL)
 828 +                 htab->root.dynobj = abfd;
 829 +               if (!create_got_section (htab->root.dynobj, info))
 830 +                 return FALSE;
 831 +             }
 832             break;
 833
 834           case R_ARM_ABS32:
 835           case R_ARM_REL32:
 836           case R_ARM_PC24:
 837 +           if (h != NULL && !info->shared)
 838 +             {
 839 +               /* If this reloc is in a read-only section, we might
 840 +                  need a copy reloc.  We can't check reliably at this
 841 +                  stage whether the section is read-only, as input
 842 +                  sections have not yet been mapped to output sections.
 843 +                  Tentatively set the flag for now, and correct in
 844 +                  adjust_dynamic_symbol.  */
 845 +               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 846 +
 847 +               /* We may need a .plt entry if the function this reloc
 848 +                  refers to is in a shared lib.  */
 849 +               h->plt.refcount += 1;
 850 +             }
 851 +
 852             /* If we are creating a shared library, and this is a reloc
 853                 against a global symbol, or a non PC relative reloc
 854                 against a local symbol, then we need to copy the reloc
 855 @@ -2784,14 +2987,17 @@
 856                 possible that DEF_REGULAR is not set now but will be set
 857                 later (it is never cleared).  We account for that
 858                 possibility below by storing information in the
 859 -               pcrel_relocs_copied field of the hash table entry.  */
 860 +               relocs_copied field of the hash table entry.  */
 861             if (info->shared
 862 -             && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
 863 -               || (h != NULL
 864 -                 && (! info->symbolic
 865 -                   || (h->elf_link_hash_flags
 866 -                     & ELF_LINK_HASH_DEF_REGULAR) == 0))))
 867 +               && (sec->flags & SEC_ALLOC) != 0
 868 +               && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
 869 +                   || (h != NULL
 870 +                       && (! info->symbolic
 871 +                           || (h->elf_link_hash_flags
 872 +                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
 873               {
 874 +               struct elf32_arm_relocs_copied *p, **head;
 875 +
 876                 /* When creating a shared object, we must copy these
 877                     reloc types into the output file.  We create a reloc
 878                     section in dynobj and make room for this reloc.  */
 879 @@ -2825,45 +3031,49 @@
 880                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 881                           return FALSE;
 882                       }
 883 -                 if (sec->flags & SEC_READONLY)
 884 -                   info->flags |= DF_TEXTREL;
 885 +
 886 +                   elf_section_data (sec)->sreloc = sreloc;
 887                   }
 888
 889 -               sreloc->_raw_size += sizeof (Elf32_External_Rel);
 890 -               /* If we are linking with -Bsymbolic, and this is a
 891 -                   global symbol, we count the number of PC relative
 892 -                   relocations we have entered for this symbol, so that
 893 -                   we can discard them again if the symbol is later
 894 -                   defined by a regular object.  Note that this function
 895 -                   is only called if we are using an elf_i386 linker
 896 -                   hash table, which means that h is really a pointer to
 897 -                   an elf_i386_link_hash_entry.  */
 898 -               if (h != NULL && info->symbolic
 899 -                   && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
 900 +               /* If this is a global symbol, we count the number of
 901 +                  relocations we need for this symbol.  */
 902 +               if (h != NULL)
 903                   {
 904 -                   struct elf32_arm_link_hash_entry * eh;
 905 -                   struct elf32_arm_pcrel_relocs_copied * p;
 906 -
 907 -                   eh = (struct elf32_arm_link_hash_entry *) h;
 908 -
 909 -                   for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
 910 -                     if (p->section == sreloc)
 911 -                       break;
 912 -
 913 +                   head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
 914 +                 }
 915 +               else
 916 +                 {
 917 +                   /* Track dynamic relocs needed for local syms too.
 918 +                      We really need local syms available to do this
 919 +                      easily.  Oh well.  */
 920 +
 921 +                   asection *s;
 922 +                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
 923 +                                                  sec, r_symndx);
 924 +                   if (s == NULL)
 925 +                     return FALSE;
 926 +
 927 +                   head = ((struct elf32_arm_relocs_copied **)
 928 +                           &elf_section_data (s)->local_dynrel);
 929 +                 }
 930 +
 931 +               p = *head;
 932 +               if (p == NULL || p->section != sec)
 933 +                 {
 934 +                   bfd_size_type amt = sizeof *p;
 935 +                   p = bfd_alloc (htab->root.dynobj, amt);
 936                     if (p == NULL)
 937 -                     {
 938 -                       p = ((struct elf32_arm_pcrel_relocs_copied *)
 939 -                            bfd_alloc (dynobj, (bfd_size_type) sizeof * p));
 940 -                       if (p == NULL)
 941 -                         return FALSE;
 942 -                       p->next = eh->pcrel_relocs_copied;
 943 -                       eh->pcrel_relocs_copied = p;
 944 -                       p->section = sreloc;
 945 -                       p->count = 0;
 946 -                     }
 947 -
 948 -                   ++p->count;
 949 +                     return FALSE;
 950 +                   p->next = *head;
 951 +                   *head = p;
 952 +                   p->section = sec;
 953 +                   p->count = 0;
 954 +                   p->pc_count = 0;
 955                   }
 956 +
 957 +               p->count += 1;
 958 +               if (ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
 959 +                 p->pc_count += 1;
 960               }
 961             break;
 962
 963 @@ -3003,71 +3213,29 @@
 964    if (h->type == STT_FUNC
 965        || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
 966      {
 967 -      /* If we link a program (not a DSO), we'll get rid of unnecessary
 968 -        PLT entries; we point to the actual symbols -- even for pic
 969 -        relocs, because a program built with -fpic should have the same
 970 -        result as one built without -fpic, specifically considering weak
 971 -        symbols.
 972 -        FIXME: m68k and i386 differ here, for unclear reasons.  */
 973 -      if (! info->shared
 974 -         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
 975 +      if (h->plt.refcount <= 0
 976 +         || SYMBOL_CALLS_LOCAL (info, h)
 977 +         || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
 978 +             && h->root.type == bfd_link_hash_undefweak))
 979         {
 980           /* This case can occur if we saw a PLT32 reloc in an input
 981 -            file, but the symbol was not defined by a dynamic object.
 982 -            In such a case, we don't actually need to build a
 983 -            procedure linkage table, and we can just do a PC32 reloc
 984 -            instead.  */
 985 -         BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
 986 +            file, but the symbol was never referred to by a dynamic
 987 +            object, or if all references were garbage collected.  In
 988 +            such a case, we don't actually need to build a procedure
 989 +            linkage table, and we can just do a PC24 reloc instead.  */
 990 +         h->plt.offset = (bfd_vma) -1;
 991           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
 992 -         return TRUE;
 993 -       }
 994 -
 995 -      /* Make sure this symbol is output as a dynamic symbol.  */
 996 -      if (h->dynindx == -1)
 997 -       {
 998 -         if (! bfd_elf32_link_record_dynamic_symbol (info, h))
 999 -           return FALSE;
1000         }
1001
1002 -      s = bfd_get_section_by_name (dynobj, ".plt");
1003 -      BFD_ASSERT (s != NULL);
1004 -
1005 -      /* If this is the first .plt entry, make room for the special
1006 -        first entry.  */
1007 -      if (s->_raw_size == 0)
1008 -       s->_raw_size += PLT_ENTRY_SIZE;
1009 -
1010 -      /* If this symbol is not defined in a regular file, and we are
1011 -        not generating a shared library, then set the symbol to this
1012 -        location in the .plt.  This is required to make function
1013 -        pointers compare as equal between the normal executable and
1014 -        the shared library.  */
1015 -      if (! info->shared
1016 -         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1017 -       {
1018 -         h->root.u.def.section = s;
1019 -         h->root.u.def.value = s->_raw_size;
1020 -       }
1021 -
1022 -      h->plt.offset = s->_raw_size;
1023 -
1024 -      /* Make room for this entry.  */
1025 -      s->_raw_size += PLT_ENTRY_SIZE;
1026 -
1027 -      /* We also need to make an entry in the .got.plt section, which
1028 -        will be placed in the .got section by the linker script.  */
1029 -      s = bfd_get_section_by_name (dynobj, ".got.plt");
1030 -      BFD_ASSERT (s != NULL);
1031 -      s->_raw_size += 4;
1032 -
1033 -      /* We also need to make an entry in the .rel.plt section.  */
1034 -
1035 -      s = bfd_get_section_by_name (dynobj, ".rel.plt");
1036 -      BFD_ASSERT (s != NULL);
1037 -      s->_raw_size += sizeof (Elf32_External_Rel);
1038 -
1039        return TRUE;
1040      }
1041 +  else
1042 +    /* It's possible that we incorrectly decided a .plt reloc was
1043 +       needed for an R_ARM_PC24 reloc to a non-function sym in
1044 +       check_relocs.  We can't decide accurately between function and
1045 +       non-function syms in check-relocs;  Objects loaded later in
1046 +       the link may change h->type.  So fix it now.  */
1047 +    h->plt.offset = (bfd_vma) -1;
1048
1049    /* If this is a weak symbol, and there is a real definition, the
1050       processor independent code will have arranged for us to see the
1051 @@ -3142,6 +3310,198 @@
1052    return TRUE;
1053  }
1054
1055 +/* Allocate space in .plt, .got and associated reloc sections for
1056 +   dynamic relocs.  */
1057 +
1058 +static bfd_boolean
1059 +allocate_dynrelocs (h, inf)
1060 +     struct elf_link_hash_entry *h;
1061 +     PTR inf;
1062 +{
1063 +  struct bfd_link_info *info;
1064 +  struct elf32_arm_link_hash_table *htab;
1065 +  struct elf32_arm_link_hash_entry *eh;
1066 +  struct elf32_arm_relocs_copied *p;
1067 +
1068 +  if (h->root.type == bfd_link_hash_indirect)
1069 +    return TRUE;
1070 +
1071 +  if (h->root.type == bfd_link_hash_warning)
1072 +    /* When warning symbols are created, they **replace** the "real"
1073 +       entry in the hash table, thus we never get to see the real
1074 +       symbol in a hash traversal.  So look at it now.  */
1075 +    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1076 +
1077 +  info = (struct bfd_link_info *) inf;
1078 +  htab = elf32_arm_hash_table (info);
1079 +
1080 +  if (htab->root.dynamic_sections_created
1081 +      && h->plt.refcount > 0)
1082 +    {
1083 +      /* Make sure this symbol is output as a dynamic symbol.
1084 +        Undefined weak syms won't yet be marked as dynamic.  */
1085 +      if (h->dynindx == -1
1086 +         && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1087 +       {
1088 +         if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1089 +           return FALSE;
1090 +       }
1091 +
1092 +      if (info->shared
1093 +         || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1094 +       {
1095 +         asection *s = htab->splt;
1096 +
1097 +         /* If this is the first .plt entry, make room for the special
1098 +            first entry.  */
1099 +         if (s->_raw_size == 0)
1100 +           s->_raw_size += PLT_HEADER_SIZE;
1101 +
1102 +         h->plt.offset = s->_raw_size;
1103 +
1104 +         /* If this symbol is not defined in a regular file, and we are
1105 +            not generating a shared library, then set the symbol to this
1106 +            location in the .plt.  This is required to make function
1107 +            pointers compare as equal between the normal executable and
1108 +            the shared library.  */
1109 +         if (! info->shared
1110 +             && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1111 +           {
1112 +             h->root.u.def.section = s;
1113 +             h->root.u.def.value = h->plt.offset;
1114 +           }
1115 +
1116 +         /* Make room for this entry.  */
1117 +         s->_raw_size += PLT_ENTRY_SIZE;
1118 +
1119 +         /* We also need to make an entry in the .got.plt section, which
1120 +            will be placed in the .got section by the linker script.  */
1121 +         htab->sgotplt->_raw_size += 4;
1122 +
1123 +         /* We also need to make an entry in the .rel.plt section.  */
1124 +         htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
1125 +       }
1126 +      else
1127 +       {
1128 +         h->plt.offset = (bfd_vma) -1;
1129 +         h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1130 +       }
1131 +    }
1132 +  else
1133 +    {
1134 +      h->plt.offset = (bfd_vma) -1;
1135 +      h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1136 +    }
1137 +
1138 +  if (h->got.refcount > 0)
1139 +    {
1140 +      asection *s;
1141 +      bfd_boolean dyn;
1142 +
1143 +      /* Make sure this symbol is output as a dynamic symbol.
1144 +        Undefined weak syms won't yet be marked as dynamic.  */
1145 +      if (h->dynindx == -1
1146 +         && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1147 +       {
1148 +         if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1149 +           return FALSE;
1150 +       }
1151 +
1152 +      s = htab->sgot;
1153 +      h->got.offset = s->_raw_size;
1154 +      s->_raw_size += 4;
1155 +      dyn = htab->root.dynamic_sections_created;
1156 +      if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1157 +          || h->root.type != bfd_link_hash_undefweak)
1158 +         && (info->shared
1159 +             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1160 +       htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1161 +    }
1162 +  else
1163 +    h->got.offset = (bfd_vma) -1;
1164 +
1165 +  eh = (struct elf32_arm_link_hash_entry *) h;
1166 +  if (eh->relocs_copied == NULL)
1167 +    return TRUE;
1168 +
1169 +  /* In the shared -Bsymbolic case, discard space allocated for
1170 +     dynamic pc-relative relocs against symbols which turn out to be
1171 +     defined in regular objects.  For the normal shared case, discard
1172 +     space for pc-relative relocs that have become local due to symbol
1173 +     visibility changes.  */
1174 +
1175 +  if (info->shared)
1176 +    {
1177 +      /* The only reloc that uses pc_count is R_ARM_PC24, which will
1178 +        appear on a call or on something like ".long foo - .".  We
1179 +        want calls to protected symbols to resolve directly to the
1180 +        function rather than going via the plt.  If people want
1181 +        function pointer comparisons to work as expected then they
1182 +        should avoid writing assembly like ".long foo - .".  */
1183 +      if (SYMBOL_CALLS_LOCAL (info, h))
1184 +       {
1185 +         struct elf32_arm_relocs_copied **pp;
1186 +
1187 +         for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
1188 +           {
1189 +             p->count -= p->pc_count;
1190 +             p->pc_count = 0;
1191 +             if (p->count == 0)
1192 +               *pp = p->next;
1193 +             else
1194 +               pp = &p->next;
1195 +           }
1196 +       }
1197 +
1198 +      /* Also discard relocs on undefined weak syms with non-default
1199 +        visibility.  */
1200 +      if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1201 +         && h->root.type == bfd_link_hash_undefweak)
1202 +       eh->relocs_copied = NULL;
1203 +    }
1204 +  else
1205 +    {
1206 +      /* For the non-shared case, discard space for relocs against
1207 +        symbols which turn out to need copy relocs or are not
1208 +        dynamic.  */
1209 +
1210 +      if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1211 +         && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1212 +              && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1213 +             || (htab->root.dynamic_sections_created
1214 +                 && (h->root.type == bfd_link_hash_undefweak
1215 +                     || h->root.type == bfd_link_hash_undefined))))
1216 +       {
1217 +         /* Make sure this symbol is output as a dynamic symbol.
1218 +            Undefined weak syms won't yet be marked as dynamic.  */
1219 +         if (h->dynindx == -1
1220 +             && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1221 +           {
1222 +             if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1223 +               return FALSE;
1224 +           }
1225 +
1226 +         /* If that succeeded, we know we'll be keeping all the
1227 +            relocs.  */
1228 +         if (h->dynindx != -1)
1229 +           goto keep;
1230 +       }
1231 +
1232 +      eh->relocs_copied = NULL;
1233 +
1234 +    keep: ;
1235 +    }
1236 +
1237 +  /* Finally, allocate space.  */
1238 +  for (p = eh->relocs_copied; p != NULL; p = p->next)
1239 +    {
1240 +      asection *sreloc = elf_section_data (p->section)->sreloc;
1241 +      sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
1242 +    }
1243 +
1244 +  return TRUE;
1245 +}
1246 +
1247  /* Set the sizes of the dynamic sections.  */
1248
1249  static bfd_boolean
1250 @@ -3153,7 +3513,10 @@
1251    asection * s;
1252    bfd_boolean plt;
1253    bfd_boolean relocs;
1254 +  bfd *ibfd;
1255 +  struct elf32_arm_link_hash_table *htab;
1256
1257 +  htab = elf32_arm_hash_table (info);
1258    dynobj = elf_hash_table (info)->dynobj;
1259    BFD_ASSERT (dynobj != NULL);
1260
1261 @@ -3168,26 +3531,74 @@
1262           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1263         }
1264      }
1265 -  else
1266 -    {
1267 -      /* We may have created entries in the .rel.got section.
1268 -         However, if we are not creating the dynamic sections, we will
1269 -         not actually use these entries.  Reset the size of .rel.got,
1270 -         which will cause it to get stripped from the output file
1271 -         below.  */
1272 -      s = bfd_get_section_by_name (dynobj, ".rel.got");
1273 -      if (s != NULL)
1274 -       s->_raw_size = 0;
1275 -    }
1276 -
1277 -  /* If this is a -Bsymbolic shared link, then we need to discard all
1278 -     PC relative relocs against symbols defined in a regular object.
1279 -     We allocated space for them in the check_relocs routine, but we
1280 -     will not fill them in in the relocate_section routine.  */
1281 -  if (info->shared && info->symbolic)
1282 -    elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
1283 -                                 elf32_arm_discard_copies,
1284 -                                 (PTR) NULL);
1285 +
1286 +  /* Set up .got offsets for local syms, and space for local dynamic
1287 +     relocs.  */
1288 +  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1289 +    {
1290 +      bfd_signed_vma *local_got;
1291 +      bfd_signed_vma *end_local_got;
1292 +      char *local_tls_type;
1293 +      bfd_size_type locsymcount;
1294 +      Elf_Internal_Shdr *symtab_hdr;
1295 +      asection *srel;
1296 +
1297 +      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1298 +       continue;
1299 +
1300 +      for (s = ibfd->sections; s != NULL; s = s->next)
1301 +       {
1302 +         struct elf32_arm_relocs_copied *p;
1303 +
1304 +         for (p = *((struct elf32_arm_relocs_copied **)
1305 +                    &elf_section_data (s)->local_dynrel);
1306 +              p != NULL;
1307 +              p = p->next)
1308 +           {
1309 +             if (!bfd_is_abs_section (p->section)
1310 +                 && bfd_is_abs_section (p->section->output_section))
1311 +               {
1312 +                 /* Input section has been discarded, either because
1313 +                    it is a copy of a linkonce section or due to
1314 +                    linker script /DISCARD/, so we'll be discarding
1315 +                    the relocs too.  */
1316 +               }
1317 +             else if (p->count != 0)
1318 +               {
1319 +                 srel = elf_section_data (p->section)->sreloc;
1320 +                 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
1321 +                 if ((p->section->output_section->flags & SEC_READONLY) != 0)
1322 +                   info->flags |= DF_TEXTREL;
1323 +               }
1324 +           }
1325 +       }
1326 +
1327 +      local_got = elf_local_got_refcounts (ibfd);
1328 +      if (!local_got)
1329 +       continue;
1330 +
1331 +      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1332 +      locsymcount = symtab_hdr->sh_info;
1333 +      end_local_got = local_got + locsymcount;
1334 +      s = htab->sgot;
1335 +      srel = htab->srelgot;
1336 +      for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1337 +       {
1338 +         if (*local_got > 0)
1339 +           {
1340 +             *local_got = s->_raw_size;
1341 +             s->_raw_size += 4;
1342 +             if (info->shared)
1343 +               srel->_raw_size += sizeof (Elf32_External_Rel);
1344 +           }
1345 +         else
1346 +           *local_got = (bfd_vma) -1;
1347 +       }
1348 +    }
1349 +
1350 +  /* Allocate global sym .plt and .got entries, and space for global
1351 +     sym dynamic relocs.  */
1352 +  elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
1353
1354    /* The check_relocs and adjust_dynamic_symbol entry points have
1355       determined the sizes of the various dynamic sections.  Allocate
1356 @@ -3312,33 +3723,6 @@
1357    return TRUE;
1358  }
1359
1360 -/* This function is called via elf32_arm_link_hash_traverse if we are
1361 -   creating a shared object with -Bsymbolic.  It discards the space
1362 -   allocated to copy PC relative relocs against symbols which are
1363 -   defined in regular objects.  We allocated space for them in the
1364 -   check_relocs routine, but we won't fill them in in the
1365 -   relocate_section routine.  */
1366 -
1367 -static bfd_boolean
1368 -elf32_arm_discard_copies (h, ignore)
1369 -     struct elf32_arm_link_hash_entry * h;
1370 -     PTR ignore ATTRIBUTE_UNUSED;
1371 -{
1372 -  struct elf32_arm_pcrel_relocs_copied * s;
1373 -
1374 -  if (h->root.root.type == bfd_link_hash_warning)
1375 -    h = (struct elf32_arm_link_hash_entry *) h->root.root.u.i.link;
1376 -
1377 -  /* We only discard relocs for symbols defined in a regular object.  */
1378 -  if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1379 -    return TRUE;
1380 -
1381 -  for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1382 -    s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1383 -
1384 -  return TRUE;
1385 -}
1386 -
1387  /* Finish up dynamic symbol handling.  We set the contents of various
1388     dynamic sections here.  */
1389
1390 @@ -3362,6 +3746,7 @@
1391        bfd_vma got_offset;
1392        Elf_Internal_Rela rel;
1393        bfd_byte *loc;
1394 +      bfd_vma got_displacement;
1395
1396        /* This symbol has an entry in the procedure linkage table.  Set
1397          it up.  */
1398 @@ -3377,35 +3762,43 @@
1399          corresponds to this symbol.  This is the index of this symbol
1400          in all the symbols for which we are making plt entries.  The
1401          first entry in the procedure linkage table is reserved.  */
1402 -      plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1403 +      plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
1404
1405        /* Get the offset into the .got table of the entry that
1406          corresponds to this function.  Each .got entry is 4 bytes.
1407          The first three are reserved.  */
1408        got_offset = (plt_index + 3) * 4;
1409
1410 +      /* Calculate the displacement between the PLT slot and the
1411 +        entry in the GOT.  */
1412 +      got_displacement = (sgot->output_section->vma
1413 +                         + sgot->output_offset
1414 +                         + got_offset
1415 +                         - splt->output_section->vma
1416 +                         - splt->output_offset
1417 +                         - h->plt.offset
1418 +                         - 8);
1419 +
1420 +      BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
1421 +
1422        /* Fill in the entry in the procedure linkage table.  */
1423 -      bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
1424 +      bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
1425                   splt->contents + h->plt.offset + 0);
1426 -      bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
1427 +      bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
1428                   splt->contents + h->plt.offset + 4);
1429 -      bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
1430 +      bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
1431                   splt->contents + h->plt.offset + 8);
1432 -      bfd_put_32 (output_bfd,
1433 -                     (sgot->output_section->vma
1434 -                      + sgot->output_offset
1435 -                      + got_offset
1436 -                      - splt->output_section->vma
1437 -                      - splt->output_offset
1438 -                      - h->plt.offset - 12),
1439 -                     splt->contents + h->plt.offset + 12);
1440 +#ifdef FOUR_WORD_PLT
1441 +      bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
1442 +                 splt->contents + h->plt.offset + 12);
1443 +#endif
1444
1445        /* Fill in the entry in the global offset table.  */
1446        bfd_put_32 (output_bfd,
1447                   (splt->output_section->vma
1448                    + splt->output_offset),
1449                   sgot->contents + got_offset);
1450 -
1451 +
1452        /* Fill in the entry in the .rel.plt section.  */
1453        rel.r_offset = (sgot->output_section->vma
1454                       + sgot->output_offset
1455 @@ -3446,16 +3839,20 @@
1456                       + sgot->output_offset
1457                       + (h->got.offset &~ (bfd_vma) 1));
1458
1459 -      /* If this is a -Bsymbolic link, and the symbol is defined
1460 -        locally, we just want to emit a RELATIVE reloc.  The entry in
1461 -        the global offset table will already have been initialized in
1462 -        the relocate_section function.  */
1463 +      /* If this is a static link, or it is a -Bsymbolic link and the
1464 +        symbol is defined locally or was forced to be local because
1465 +        of a version file, we just want to emit a RELATIVE reloc.
1466 +        The entry in the global offset table will already have been
1467 +        initialized in the relocate_section function.  */
1468        if (info->shared
1469 -         && (info->symbolic || h->dynindx == -1)
1470 -         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1471 -       rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1472 +         && SYMBOL_REFERENCES_LOCAL (info, h))
1473 +       {
1474 +         BFD_ASSERT((h->got.offset & 1) != 0);
1475 +         rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1476 +       }
1477        else
1478         {
1479 +         BFD_ASSERT((h->got.offset & 1) == 0);
1480           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1481           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
1482         }
1483 @@ -3609,10 +4006,26 @@
1484        /* Fill in the first entry in the procedure linkage table.  */
1485        if (splt->_raw_size > 0)
1486         {
1487 +         bfd_vma got_displacement;
1488 +
1489 +         /* Calculate the displacement between the PLT slot and &GOT[0].  */
1490 +         got_displacement = (sgot->output_section->vma
1491 +                             + sgot->output_offset
1492 +                             - splt->output_section->vma
1493 +                             - splt->output_offset
1494 +                             - 16);
1495 +
1496           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents +  0);
1497           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents +  4);
1498           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents +  8);
1499           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
1500 +#ifdef FOUR_WORD_PLT
1501 +         /* The displacement value goes in the otherwise-unused last word of
1502 +            the second entry.  */
1503 +         bfd_put_32 (output_bfd, got_displacement,        splt->contents + 28);
1504 +#else
1505 +         bfd_put_32 (output_bfd, got_displacement,        splt->contents + 16);
1506 +#endif
1507         }
1508
1509        /* UnixWare sets the entsize of .plt to 4, although that doesn't
1510 @@ -3714,7 +4127,7 @@
1511  #define elf_backend_check_relocs                elf32_arm_check_relocs
1512  #define elf_backend_relocate_section           elf32_arm_relocate_section
1513  #define elf_backend_adjust_dynamic_symbol      elf32_arm_adjust_dynamic_symbol
1514 -#define elf_backend_create_dynamic_sections    _bfd_elf_create_dynamic_sections
1515 +#define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
1516  #define elf_backend_finish_dynamic_symbol      elf32_arm_finish_dynamic_symbol
1517  #define elf_backend_finish_dynamic_sections    elf32_arm_finish_dynamic_sections
1518  #define elf_backend_size_dynamic_sections      elf32_arm_size_dynamic_sections
1519 @@ -3723,7 +4136,9 @@
1520  #define elf_backend_object_p                   elf32_arm_object_p
1521  #define elf_backend_section_flags              elf32_arm_section_flags
1522  #define elf_backend_final_write_processing      elf32_arm_final_write_processing
1523 +#define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
1524
1525 +#define elf_backend_can_refcount    1
1526  #define elf_backend_can_gc_sections 1
1527  #define elf_backend_plt_readonly    1
1528  #define elf_backend_want_got_plt    1
1529 @@ -3733,7 +4148,7 @@
1530  #endif
1531
1532  #define elf_backend_got_header_size    12
1533 -#define elf_backend_plt_header_size    PLT_ENTRY_SIZE
1534 +#define elf_backend_plt_header_size    PLT_HEADER_SIZE
1535
1536  #include "elf32-target.h"
1537
1538 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-avr.c binutils-2.14.90.0.7/bfd/elf32-avr.c
1539 --- binutils-2.14.90.0.7.orig/bfd/elf32-avr.c   2003-07-23 09:08:08.000000000 -0600
1540 +++ binutils-2.14.90.0.7/bfd/elf32-avr.c        2004-04-20 01:26:12.000000000 -0600
1541 @@ -750,7 +750,7 @@
1542         {
1543           sym = local_syms + r_symndx;
1544           sec = local_sections [r_symndx];
1545 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1546 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1547
1548           name = bfd_elf_string_from_elf_section
1549             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1550 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-cris.c binutils-2.14.90.0.7/bfd/elf32-cris.c
1551 --- binutils-2.14.90.0.7.orig/bfd/elf32-cris.c  2003-08-21 09:28:47.000000000 -0600
1552 +++ binutils-2.14.90.0.7/bfd/elf32-cris.c       2004-04-20 01:26:12.000000000 -0600
1553 @@ -847,7 +847,7 @@
1554         {
1555           sym = local_syms + r_symndx;
1556           sec = local_sections [r_symndx];
1557 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1558 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1559
1560           symname = (bfd_elf_string_from_elf_section
1561                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
1562 @@ -1292,16 +1292,7 @@
1563                     {
1564                       long indx;
1565
1566 -                     if (h == NULL)
1567 -                       sec = local_sections[r_symndx];
1568 -                     else
1569 -                       {
1570 -                         BFD_ASSERT (h->root.type == bfd_link_hash_defined
1571 -                                     || (h->root.type
1572 -                                         == bfd_link_hash_defweak));
1573 -                         sec = h->root.u.def.section;
1574 -                       }
1575 -                     if (sec != NULL && bfd_is_abs_section (sec))
1576 +                     if (bfd_is_abs_section (sec))
1577                         indx = 0;
1578                       else if (sec == NULL || sec->owner == NULL)
1579                         {
1580 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-fr30.c binutils-2.14.90.0.7/bfd/elf32-fr30.c
1581 --- binutils-2.14.90.0.7.orig/bfd/elf32-fr30.c  2003-07-23 09:08:08.000000000 -0600
1582 +++ binutils-2.14.90.0.7/bfd/elf32-fr30.c       2004-04-20 01:26:12.000000000 -0600
1583 @@ -552,7 +552,7 @@
1584         {
1585           sym = local_syms + r_symndx;
1586           sec = local_sections [r_symndx];
1587 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1588 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1589
1590           name = bfd_elf_string_from_elf_section
1591             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1592 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-frv.c binutils-2.14.90.0.7/bfd/elf32-frv.c
1593 --- binutils-2.14.90.0.7.orig/bfd/elf32-frv.c   2003-10-29 10:37:47.000000000 -0700
1594 +++ binutils-2.14.90.0.7/bfd/elf32-frv.c        2004-04-20 01:26:12.000000000 -0600
1595 @@ -724,7 +724,7 @@
1596         {
1597           sym = local_syms + r_symndx;
1598           sec = local_sections [r_symndx];
1599 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1600 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1601
1602           name = bfd_elf_string_from_elf_section
1603             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1604 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-h8300.c binutils-2.14.90.0.7/bfd/elf32-h8300.c
1605 --- binutils-2.14.90.0.7.orig/bfd/elf32-h8300.c 2003-10-29 10:37:47.000000000 -0700
1606 +++ binutils-2.14.90.0.7/bfd/elf32-h8300.c      2004-04-20 01:26:12.000000000 -0600
1607 @@ -435,7 +435,7 @@
1608         {
1609           sym = local_syms + r_symndx;
1610           sec = local_sections[r_symndx];
1611 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1612 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1613         }
1614        else
1615         {
1616 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-hppa.c binutils-2.14.90.0.7/bfd/elf32-hppa.c
1617 --- binutils-2.14.90.0.7.orig/bfd/elf32-hppa.c  2003-10-29 10:37:47.000000000 -0700
1618 +++ binutils-2.14.90.0.7/bfd/elf32-hppa.c       2004-04-20 01:26:12.000000000 -0600
1619 @@ -3408,7 +3408,7 @@
1620           /* This is a local symbol, h defaults to NULL.  */
1621           sym = local_syms + r_symndx;
1622           sym_sec = local_sections[r_symndx];
1623 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
1624 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
1625         }
1626        else
1627         {
1628 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-i370.c binutils-2.14.90.0.7/bfd/elf32-i370.c
1629 --- binutils-2.14.90.0.7.orig/bfd/elf32-i370.c  2003-07-23 09:08:08.000000000 -0600
1630 +++ binutils-2.14.90.0.7/bfd/elf32-i370.c       2004-04-20 01:26:12.000000000 -0600
1631 @@ -1210,7 +1210,7 @@
1632           sec = local_sections[r_symndx];
1633           sym_name = "<local symbol>";
1634
1635 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1636 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1637           addend = rel->r_addend;
1638         }
1639        else
1640 @@ -1363,16 +1363,7 @@
1641                     {
1642                       long indx;
1643
1644 -                     if (h == NULL)
1645 -                       sec = local_sections[r_symndx];
1646 -                     else
1647 -                       {
1648 -                         BFD_ASSERT (h->root.type == bfd_link_hash_defined
1649 -                                     || (h->root.type
1650 -                                         == bfd_link_hash_defweak));
1651 -                         sec = h->root.u.def.section;
1652 -                       }
1653 -                     if (sec != NULL && bfd_is_abs_section (sec))
1654 +                     if (bfd_is_abs_section (sec))
1655                         indx = 0;
1656                       else if (sec == NULL || sec->owner == NULL)
1657                         {
1658 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-i860.c binutils-2.14.90.0.7/bfd/elf32-i860.c
1659 --- binutils-2.14.90.0.7.orig/bfd/elf32-i860.c  2003-10-29 10:37:47.000000000 -0700
1660 +++ binutils-2.14.90.0.7/bfd/elf32-i860.c       2004-04-20 01:26:12.000000000 -0600
1661 @@ -1104,7 +1104,7 @@
1662         {
1663           sym = local_syms + r_symndx;
1664           sec = local_sections [r_symndx];
1665 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1666 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1667
1668           name = bfd_elf_string_from_elf_section
1669             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1670 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-m32r.c binutils-2.14.90.0.7/bfd/elf32-m32r.c
1671 --- binutils-2.14.90.0.7.orig/bfd/elf32-m32r.c  2003-10-29 10:37:47.000000000 -0700
1672 +++ binutils-2.14.90.0.7/bfd/elf32-m32r.c       2004-04-20 01:26:12.000000000 -0600
1673 @@ -1107,7 +1107,7 @@
1674               sec = local_sections[r_symndx];
1675               sym_name = "<local symbol>";
1676  #if !USE_REL
1677 -             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1678 +             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1679               addend = rel->r_addend;
1680  #else
1681               /* FIXME: This won't handle local relocations against SEC_MERGE
1682 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-m68k.c binutils-2.14.90.0.7/bfd/elf32-m68k.c
1683 --- binutils-2.14.90.0.7.orig/bfd/elf32-m68k.c  2003-08-21 09:28:47.000000000 -0600
1684 +++ binutils-2.14.90.0.7/bfd/elf32-m68k.c       2004-04-20 01:26:12.000000000 -0600
1685 @@ -1403,7 +1403,7 @@
1686         {
1687           sym = local_syms + r_symndx;
1688           sec = local_sections[r_symndx];
1689 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1690 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1691         }
1692        else
1693         {
1694 @@ -1657,16 +1657,7 @@
1695                     {
1696                       long indx;
1697
1698 -                     if (h == NULL)
1699 -                       sec = local_sections[r_symndx];
1700 -                     else
1701 -                       {
1702 -                         BFD_ASSERT (h->root.type == bfd_link_hash_defined
1703 -                                     || (h->root.type
1704 -                                         == bfd_link_hash_defweak));
1705 -                         sec = h->root.u.def.section;
1706 -                       }
1707 -                     if (sec != NULL && bfd_is_abs_section (sec))
1708 +                     if (bfd_is_abs_section (sec))
1709                         indx = 0;
1710                       else if (sec == NULL || sec->owner == NULL)
1711                         {
1712 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-mcore.c binutils-2.14.90.0.7/bfd/elf32-mcore.c
1713 --- binutils-2.14.90.0.7.orig/bfd/elf32-mcore.c 2003-10-29 10:37:48.000000000 -0700
1714 +++ binutils-2.14.90.0.7/bfd/elf32-mcore.c      2004-04-20 01:26:12.000000000 -0600
1715 @@ -467,7 +467,7 @@
1716         {
1717           sym = local_syms + r_symndx;
1718           sec = local_sections [r_symndx];
1719 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1720 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1721           addend = rel->r_addend;
1722         }
1723        else
1724 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-msp430.c binutils-2.14.90.0.7/bfd/elf32-msp430.c
1725 --- binutils-2.14.90.0.7.orig/bfd/elf32-msp430.c        2003-08-21 09:28:47.000000000 -0600
1726 +++ binutils-2.14.90.0.7/bfd/elf32-msp430.c     2004-04-20 01:26:12.000000000 -0600
1727 @@ -449,7 +449,7 @@
1728         {
1729           sym = local_syms + r_symndx;
1730           sec = local_sections[r_symndx];
1731 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1732 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1733
1734           name = bfd_elf_string_from_elf_section
1735               (input_bfd, symtab_hdr->sh_link, sym->st_name);
1736 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-openrisc.c binutils-2.14.90.0.7/bfd/elf32-openrisc.c
1737 --- binutils-2.14.90.0.7.orig/bfd/elf32-openrisc.c      2003-07-23 09:08:08.000000000 -0600
1738 +++ binutils-2.14.90.0.7/bfd/elf32-openrisc.c   2004-04-20 01:26:12.000000000 -0600
1739 @@ -375,7 +375,7 @@
1740         {
1741           sym = local_syms + r_symndx;
1742           sec = local_sections[r_symndx];
1743 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1744 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1745
1746           name = bfd_elf_string_from_elf_section
1747             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1748 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-ppc.c binutils-2.14.90.0.7/bfd/elf32-ppc.c
1749 --- binutils-2.14.90.0.7.orig/bfd/elf32-ppc.c   2003-10-29 10:37:48.000000000 -0700
1750 +++ binutils-2.14.90.0.7/bfd/elf32-ppc.c        2004-04-20 01:26:12.000000000 -0600
1751 @@ -4727,7 +4727,7 @@
1752           sec = local_sections[r_symndx];
1753           sym_name = bfd_elf_local_sym_name (input_bfd, sym);
1754
1755 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1756 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1757         }
1758        else
1759         {
1760 @@ -5455,44 +5455,9 @@
1761           break;
1762
1763         case R_PPC_RELAX32:
1764 -         {
1765 -           unsigned long r_symndx;
1766 -           Elf_Internal_Sym *sym;
1767 -           asection *sym_sec;
1768 -           bfd_byte *hit_addr = 0;
1769 -           bfd_vma value = 0;
1770 -
1771 -           r_symndx = ELF32_R_SYM (rel->r_info);
1772 -
1773 -           if (r_symndx < symtab_hdr->sh_info)
1774 -             {
1775 -               sym = local_syms + r_symndx;
1776 -               sym_sec = local_sections[r_symndx];
1777 -
1778 -               value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
1779 -             }
1780 -           else
1781 -             {
1782 -               bfd_boolean warned;
1783 -               bfd_boolean unresolved_reloc;
1784 -
1785 -               RELOC_FOR_GLOBAL_SYMBOL (h, elf_sym_hashes (input_bfd),
1786 -                                        r_symndx, symtab_hdr,
1787 -                                        value, sym_sec,
1788 -                                        unresolved_reloc, info,
1789 -                                        warned);
1790 -               if (warned)
1791 -                 continue;
1792 -             }
1793 -           hit_addr = contents + rel->r_offset;
1794 -           value += rel->r_addend;
1795 -
1796 -           r = ppc_elf_install_value (output_bfd, hit_addr, value, r_type);
1797 -           if (r != bfd_reloc_ok)
1798 -             break;
1799 -           else
1800 -             continue;
1801 -         }
1802 +         ppc_elf_install_value (output_bfd, contents + rel->r_offset,
1803 +                                relocation + addend, r_type);
1804 +         continue;
1805
1806           /* Indirect .sdata relocation.  */
1807         case R_PPC_EMB_SDAI16:
1808 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-s390.c binutils-2.14.90.0.7/bfd/elf32-s390.c
1809 --- binutils-2.14.90.0.7.orig/bfd/elf32-s390.c  2003-08-21 09:28:47.000000000 -0600
1810 +++ binutils-2.14.90.0.7/bfd/elf32-s390.c       2004-04-20 01:26:12.000000000 -0600
1811 @@ -2327,7 +2327,7 @@
1812         {
1813           sym = local_syms + r_symndx;
1814           sec = local_sections[r_symndx];
1815 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1816 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1817         }
1818        else
1819         {
1820 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-sh.c binutils-2.14.90.0.7/bfd/elf32-sh.c
1821 --- binutils-2.14.90.0.7.orig/bfd/elf32-sh.c    2003-10-29 10:37:48.000000000 -0700
1822 +++ binutils-2.14.90.0.7/bfd/elf32-sh.c 2004-04-20 01:26:12.000000000 -0600
1823 @@ -4805,7 +4805,7 @@
1824             }
1825           else if (! howto->partial_inplace)
1826             {
1827 -             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1828 +             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1829               addend = rel->r_addend;
1830             }
1831           else if ((sec->flags & SEC_MERGE)
1832 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-sparc.c binutils-2.14.90.0.7/bfd/elf32-sparc.c
1833 --- binutils-2.14.90.0.7.orig/bfd/elf32-sparc.c 2003-08-21 09:28:48.000000000 -0600
1834 +++ binutils-2.14.90.0.7/bfd/elf32-sparc.c      2004-04-20 01:26:12.000000000 -0600
1835 @@ -2182,7 +2182,7 @@
1836         {
1837           sym = local_syms + r_symndx;
1838           sec = local_sections[r_symndx];
1839 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1840 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1841         }
1842        else
1843         {
1844 @@ -2459,16 +2459,8 @@
1845
1846                       if (is_plt)
1847                         sec = htab->splt;
1848 -                     else if (h == NULL)
1849 -                       sec = local_sections[r_symndx];
1850 -                     else
1851 -                       {
1852 -                         BFD_ASSERT (h->root.type == bfd_link_hash_defined
1853 -                                     || (h->root.type
1854 -                                         == bfd_link_hash_defweak));
1855 -                         sec = h->root.u.def.section;
1856 -                       }
1857 -                     if (sec != NULL && bfd_is_abs_section (sec))
1858 +
1859 +                     if (bfd_is_abs_section (sec))
1860                         indx = 0;
1861                       else if (sec == NULL || sec->owner == NULL)
1862                         {
1863 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-v850.c binutils-2.14.90.0.7/bfd/elf32-v850.c
1864 --- binutils-2.14.90.0.7.orig/bfd/elf32-v850.c  2003-10-29 10:37:48.000000000 -0700
1865 +++ binutils-2.14.90.0.7/bfd/elf32-v850.c       2004-04-20 01:26:12.000000000 -0600
1866 @@ -1681,7 +1681,7 @@
1867         {
1868           sym = local_syms + r_symndx;
1869           sec = local_sections[r_symndx];
1870 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1871 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1872  #if 0
1873           {
1874             char * name;
1875 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-vax.c binutils-2.14.90.0.7/bfd/elf32-vax.c
1876 --- binutils-2.14.90.0.7.orig/bfd/elf32-vax.c   2003-08-21 09:28:48.000000000 -0600
1877 +++ binutils-2.14.90.0.7/bfd/elf32-vax.c        2004-04-20 01:26:12.000000000 -0600
1878 @@ -1483,7 +1483,7 @@
1879         {
1880           sym = local_syms + r_symndx;
1881           sec = local_sections[r_symndx];
1882 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1883 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1884         }
1885        else
1886         {
1887 @@ -1737,16 +1737,7 @@
1888                     {
1889                       long indx;
1890
1891 -                     if (h == NULL)
1892 -                       sec = local_sections[r_symndx];
1893 -                     else
1894 -                       {
1895 -                         BFD_ASSERT (h->root.type == bfd_link_hash_defined
1896 -                                     || (h->root.type
1897 -                                         == bfd_link_hash_defweak));
1898 -                         sec = h->root.u.def.section;
1899 -                       }
1900 -                     if (sec != NULL && bfd_is_abs_section (sec))
1901 +                     if (bfd_is_abs_section (sec))
1902                         indx = 0;
1903                       else if (sec == NULL || sec->owner == NULL)
1904                         {
1905 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-xstormy16.c binutils-2.14.90.0.7/bfd/elf32-xstormy16.c
1906 --- binutils-2.14.90.0.7.orig/bfd/elf32-xstormy16.c     2003-07-23 09:08:09.000000000 -0600
1907 +++ binutils-2.14.90.0.7/bfd/elf32-xstormy16.c  2004-04-20 01:26:12.000000000 -0600
1908 @@ -845,7 +845,7 @@
1909         {
1910           sym = local_syms + r_symndx;
1911           sec = local_sections [r_symndx];
1912 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1913 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1914
1915           name = bfd_elf_string_from_elf_section
1916             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1917 diff -urN binutils-2.14.90.0.7.orig/bfd/elf32-xtensa.c binutils-2.14.90.0.7/bfd/elf32-xtensa.c
1918 --- binutils-2.14.90.0.7.orig/bfd/elf32-xtensa.c        2003-10-29 10:37:48.000000000 -0700
1919 +++ binutils-2.14.90.0.7/bfd/elf32-xtensa.c     2004-04-20 01:26:12.000000000 -0600
1920 @@ -2004,7 +2004,7 @@
1921         {
1922           sym = local_syms + r_symndx;
1923           sec = local_sections[r_symndx];
1924 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1925 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1926         }
1927        else
1928         {
1929 diff -urN binutils-2.14.90.0.7.orig/bfd/elf64-alpha.c binutils-2.14.90.0.7/bfd/elf64-alpha.c
1930 --- binutils-2.14.90.0.7.orig/bfd/elf64-alpha.c 2003-10-29 10:37:48.000000000 -0700
1931 +++ binutils-2.14.90.0.7/bfd/elf64-alpha.c      2004-04-20 01:26:12.000000000 -0600
1932 @@ -4394,9 +4394,11 @@
1933
1934        if (r_symndx < symtab_hdr->sh_info)
1935         {
1936 +         asection *msec;
1937           sym = local_syms + r_symndx;
1938           sec = local_sections[r_symndx];
1939 -         value = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1940 +         msec = sec;
1941 +         value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
1942
1943           /* If this is a tp-relative relocation against sym 0,
1944              this is hackery from relax_section.  Force the value to
1945 @@ -4424,7 +4426,6 @@
1946               && !gotent->reloc_xlated)
1947             {
1948               struct alpha_elf_got_entry *ent;
1949 -             asection *msec;
1950
1951               for (ent = gotent; ent; ent = ent->next)
1952                 {
1953 diff -urN binutils-2.14.90.0.7.orig/bfd/elf64-hppa.c binutils-2.14.90.0.7/bfd/elf64-hppa.c
1954 --- binutils-2.14.90.0.7.orig/bfd/elf64-hppa.c  2003-10-29 10:37:48.000000000 -0700
1955 +++ binutils-2.14.90.0.7/bfd/elf64-hppa.c       2004-04-20 01:26:12.000000000 -0600
1956 @@ -173,7 +173,7 @@
1957            PTR info));
1958
1959  static const char *get_dyn_name
1960 -  PARAMS ((asection *, struct elf_link_hash_entry *,
1961 +  PARAMS ((bfd *, struct elf_link_hash_entry *,
1962            const Elf_Internal_Rela *, char **, size_t *));
1963
1964  /* This must follow the definitions of the various derived linker
1965 @@ -446,13 +446,14 @@
1966     allocate memory as necessary, possibly reusing PBUF/PLEN.  */
1967
1968  static const char *
1969 -get_dyn_name (sec, h, rel, pbuf, plen)
1970 -     asection *sec;
1971 +get_dyn_name (abfd, h, rel, pbuf, plen)
1972 +     bfd *abfd;
1973       struct elf_link_hash_entry *h;
1974       const Elf_Internal_Rela *rel;
1975       char **pbuf;
1976       size_t *plen;
1977  {
1978 +  asection *sec = abfd->sections;
1979    size_t nlen, tlen;
1980    char *buf;
1981    size_t len;
1982 @@ -858,7 +859,7 @@
1983         continue;
1984
1985        /* Collect a canonical name for this address.  */
1986 -      addr_name = get_dyn_name (sec, h, rel, &buf, &buf_len);
1987 +      addr_name = get_dyn_name (abfd, h, rel, &buf, &buf_len);
1988
1989        /* Collect the canonical entry data for this address.  */
1990        dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1991 diff -urN binutils-2.14.90.0.7.orig/bfd/elf64-mmix.c binutils-2.14.90.0.7/bfd/elf64-mmix.c
1992 --- binutils-2.14.90.0.7.orig/bfd/elf64-mmix.c  2003-10-29 10:37:48.000000000 -0700
1993 +++ binutils-2.14.90.0.7/bfd/elf64-mmix.c       2004-04-20 01:26:12.000000000 -0600
1994 @@ -1472,7 +1472,7 @@
1995         {
1996           sym = local_syms + r_symndx;
1997           sec = local_sections [r_symndx];
1998 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1999 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2000
2001           name = bfd_elf_string_from_elf_section
2002             (input_bfd, symtab_hdr->sh_link, sym->st_name);
2003 diff -urN binutils-2.14.90.0.7.orig/bfd/elf64-ppc.c binutils-2.14.90.0.7/bfd/elf64-ppc.c
2004 --- binutils-2.14.90.0.7.orig/bfd/elf64-ppc.c   2003-10-29 10:37:48.000000000 -0700
2005 +++ binutils-2.14.90.0.7/bfd/elf64-ppc.c        2004-04-20 01:26:12.000000000 -0600
2006 @@ -7385,7 +7385,7 @@
2007           sec = local_sections[r_symndx];
2008           sym_name = bfd_elf_local_sym_name (input_bfd, sym);
2009           sym_type = ELF64_ST_TYPE (sym->st_info);
2010 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2011 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2012           if (elf_section_data (sec) != NULL)
2013             {
2014               long *opd_sym_adjust;
2015 @@ -8178,7 +8178,9 @@
2016           relocation = TOCstart;
2017           if (r_symndx == 0)
2018             relocation += htab->stub_group[input_section->id].toc_off;
2019 -         else if (sec != NULL && !unresolved_reloc)
2020 +         else if (unresolved_reloc)
2021 +           ;
2022 +         else if (sec != NULL && sec->id <= htab->top_id)
2023             relocation += htab->stub_group[sec->id].toc_off;
2024           else
2025             unresolved_reloc = TRUE;
2026 diff -urN binutils-2.14.90.0.7.orig/bfd/elf64-s390.c binutils-2.14.90.0.7/bfd/elf64-s390.c
2027 --- binutils-2.14.90.0.7.orig/bfd/elf64-s390.c  2003-08-21 09:28:48.000000000 -0600
2028 +++ binutils-2.14.90.0.7/bfd/elf64-s390.c       2004-04-20 01:26:12.000000000 -0600
2029 @@ -2297,7 +2297,7 @@
2030         {
2031           sym = local_syms + r_symndx;
2032           sec = local_sections[r_symndx];
2033 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2034 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2035         }
2036        else
2037         {
2038 diff -urN binutils-2.14.90.0.7.orig/bfd/elf64-sh64.c binutils-2.14.90.0.7/bfd/elf64-sh64.c
2039 --- binutils-2.14.90.0.7.orig/bfd/elf64-sh64.c  2003-10-29 10:37:48.000000000 -0700
2040 +++ binutils-2.14.90.0.7/bfd/elf64-sh64.c       2004-04-20 01:26:12.000000000 -0600
2041 @@ -1582,7 +1582,7 @@
2042             }
2043           else if (! howto->partial_inplace)
2044             {
2045 -             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2046 +             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2047               relocation |= ((sym->st_other & STO_SH5_ISA32) != 0);
2048             }
2049           else if ((sec->flags & SEC_MERGE)
2050 diff -urN binutils-2.14.90.0.7.orig/bfd/elf64-sparc.c binutils-2.14.90.0.7/bfd/elf64-sparc.c
2051 --- binutils-2.14.90.0.7.orig/bfd/elf64-sparc.c 2003-08-21 09:28:48.000000000 -0600
2052 +++ binutils-2.14.90.0.7/bfd/elf64-sparc.c      2004-04-20 01:26:12.000000000 -0600
2053 @@ -2070,7 +2070,7 @@
2054         {
2055           sym = local_syms + r_symndx;
2056           sec = local_sections[r_symndx];
2057 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2058 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2059         }
2060        else
2061         {
2062 @@ -2247,16 +2247,8 @@
2063
2064                         if (is_plt)
2065                           sec = splt;
2066 -                       else if (h == NULL)
2067 -                         sec = local_sections[r_symndx];
2068 -                       else
2069 -                         {
2070 -                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
2071 -                                       || (h->root.type
2072 -                                           == bfd_link_hash_defweak));
2073 -                           sec = h->root.u.def.section;
2074 -                         }
2075 -                       if (sec != NULL && bfd_is_abs_section (sec))
2076 +
2077 +                       if (bfd_is_abs_section (sec))
2078                           indx = 0;
2079                         else if (sec == NULL || sec->owner == NULL)
2080                           {
2081 diff -urN binutils-2.14.90.0.7.orig/bfd/elf64-x86-64.c binutils-2.14.90.0.7/bfd/elf64-x86-64.c
2082 --- binutils-2.14.90.0.7.orig/bfd/elf64-x86-64.c        2003-08-21 09:28:48.000000000 -0600
2083 +++ binutils-2.14.90.0.7/bfd/elf64-x86-64.c     2004-04-20 01:26:12.000000000 -0600
2084 @@ -1823,7 +1823,7 @@
2085           sym = local_syms + r_symndx;
2086           sec = local_sections[r_symndx];
2087
2088 -         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2089 +         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2090         }
2091        else
2092         {
2093 @@ -2048,16 +2048,7 @@
2094                     {
2095                       long sindx;
2096
2097 -                     if (h == NULL)
2098 -                       sec = local_sections[r_symndx];
2099 -                     else
2100 -                       {
2101 -                         BFD_ASSERT (h->root.type == bfd_link_hash_defined
2102 -                                     || (h->root.type
2103 -                                         == bfd_link_hash_defweak));
2104 -                         sec = h->root.u.def.section;
2105 -                       }
2106 -                     if (sec != NULL && bfd_is_abs_section (sec))
2107 +                     if (bfd_is_abs_section (sec))
2108                         sindx = 0;
2109                       else if (sec == NULL || sec->owner == NULL)
2110                         {
2111 diff -urN binutils-2.14.90.0.7.orig/bfd/elfxx-ia64.c binutils-2.14.90.0.7/bfd/elfxx-ia64.c
2112 --- binutils-2.14.90.0.7.orig/bfd/elfxx-ia64.c  2003-10-29 10:37:48.000000000 -0700
2113 +++ binutils-2.14.90.0.7/bfd/elfxx-ia64.c       2004-04-20 01:26:12.000000000 -0600
2114 @@ -3849,9 +3849,11 @@
2115        if (r_symndx < symtab_hdr->sh_info)
2116         {
2117           /* Reloc against local symbol.  */
2118 +         asection *msec;
2119           sym = local_syms + r_symndx;
2120           sym_sec = local_sections[r_symndx];
2121 -         value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
2122 +         msec = sym_sec;
2123 +         value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
2124           if ((sym_sec->flags & SEC_MERGE)
2125               && ELF_ST_TYPE (sym->st_info) == STT_SECTION
2126               && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2127 @@ -3862,7 +3864,6 @@
2128               if (loc_h && ! loc_h->sec_merge_done)
2129                 {
2130                   struct elfNN_ia64_dyn_sym_info *dynent;
2131 -                 asection *msec;
2132
2133                   for (dynent = loc_h->info; dynent; dynent = dynent->next)
2134                     {
2135 diff -urN binutils-2.14.90.0.7.orig/bfd/opncls.c binutils-2.14.90.0.7/bfd/opncls.c
2136 --- binutils-2.14.90.0.7.orig/bfd/opncls.c      2003-10-29 10:37:48.000000000 -0700
2137 +++ binutils-2.14.90.0.7/bfd/opncls.c   2004-04-20 01:26:11.000000000 -0600
2138 @@ -150,6 +150,13 @@
2139  {
2140    bfd *nbfd;
2141    const bfd_target *target_vec;
2142 +  struct stat s;
2143 +
2144 +  if (stat (filename, &s) == 0)
2145 +    if (S_ISDIR(s.st_mode)) {
2146 +      bfd_set_error (bfd_error_file_not_recognized);
2147 +      return NULL;
2148 +    }
2149
2150    nbfd = _bfd_new_bfd ();
2151    if (nbfd == NULL)
2152 diff -urN binutils-2.14.90.0.7.orig/binutils/objcopy.c binutils-2.14.90.0.7/binutils/objcopy.c
2153 --- binutils-2.14.90.0.7.orig/binutils/objcopy.c        2003-10-29 10:37:48.000000000 -0700
2154 +++ binutils-2.14.90.0.7/binutils/objcopy.c     2004-04-20 01:26:12.000000000 -0600
2155 @@ -27,6 +27,7 @@
2156  #include "libiberty.h"
2157  #include "budbg.h"
2158  #include "filenames.h"
2159 +#include "elf-bfd.h"
2160  #include <sys/stat.h>
2161
2162  /* A list of symbols to explicitly strip out, or to keep.  A linked
2163 @@ -385,6 +386,7 @@
2164    -g --strip-debug                 Remove all debugging symbols & sections\n\
2165       --strip-unneeded              Remove all symbols not needed by relocations\n\
2166    -N --strip-symbol <name>         Do not copy symbol <name>\n\
2167 +     --only-keep-debug             Strip everything but the debug information\n\
2168    -K --keep-symbol <name>          Only copy symbol <name>\n\
2169    -L --localize-symbol <name>      Force symbol <name> to be marked as a local\n\
2170    -G --keep-global-symbol <name>   Localize all symbols except <name>\n\
2171 @@ -457,6 +459,7 @@
2172    -s --strip-all                   Remove all symbol and relocation information\n\
2173    -g -S -d --strip-debug           Remove all debugging symbols & sections\n\
2174       --strip-unneeded              Remove all symbols not needed by relocations\n\
2175 +     --only-keep-debug             Strip everything but the debug information\n\
2176    -N --strip-symbol=<name>         Do not copy symbol <name>\n\
2177    -K --keep-symbol=<name>          Only copy symbol <name>\n\
2178    -x --discard-all                 Remove all non-global symbols\n\
2179 @@ -734,7 +737,7 @@
2180         return FALSE;
2181      }
2182
2183 -  return strip_symbols == STRIP_NONDEBUG ? TRUE : FALSE;
2184 +  return FALSE;
2185  }
2186
2187  /* Choose which symbol entries to copy; put the result in OSYMS.
2188 @@ -1806,6 +1809,13 @@
2189
2190    if (p != NULL && p->set_flags)
2191      flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2192 +  else if (strip_symbols == STRIP_NONDEBUG && (flags & SEC_ALLOC) != 0)
2193 +    {
2194 +      flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD);
2195 +      if (obfd->xvec->flavour == bfd_target_elf_flavour)
2196 +       elf_section_type (osection) = SHT_NOBITS;
2197 +    }
2198 +
2199    if (!bfd_set_section_flags (obfd, osection, flags))
2200      {
2201        err = _("flags");
2202 @@ -1926,6 +1936,8 @@
2203         }
2204
2205        bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
2206 +      if (relcount == 0)
2207 +       free (relpp);
2208      }
2209
2210    isection->_cooked_size = isection->_raw_size;
2211 diff -urN binutils-2.14.90.0.7.orig/binutils/readelf.c binutils-2.14.90.0.7/binutils/readelf.c
2212 --- binutils-2.14.90.0.7.orig/binutils/readelf.c        2003-10-29 10:37:48.000000000 -0700
2213 +++ binutils-2.14.90.0.7/binutils/readelf.c     2004-04-20 01:26:12.000000000 -0600
2214 @@ -6055,7 +6055,7 @@
2215
2216    bytes = section->sh_size;
2217
2218 -  if (bytes == 0)
2219 +  if (bytes == 0 || section->sh_type == SHT_NOBITS)
2220      {
2221        printf (_("\nSection '%s' has no data to dump.\n"),
2222               SECTION_NAME (section));
2223 diff -urN binutils-2.14.90.0.7.orig/gprof/gprof.texi binutils-2.14.90.0.7/gprof/gprof.texi
2224 --- binutils-2.14.90.0.7.orig/gprof/gprof.texi  2002-08-01 18:49:32.000000000 -0600
2225 +++ binutils-2.14.90.0.7/gprof/gprof.texi       2004-04-20 01:26:11.000000000 -0600
2226 @@ -137,6 +137,10 @@
2227  If more than one profile file is specified, the @code{gprof}
2228  output shows the sum of the profile information in the given profile files.
2229
2230 +If you use gcc 2.95.x or 3.0 to compile your binaries, you may need
2231 +to add the @samp{-fprofile-arcs} to the compile command line in order
2232 +for the call graphs to be properly stored in gmon.out.
2233 +
2234  @code{Gprof} calculates the amount of time spent in each routine.
2235  Next, these times are propagated along the edges of the call graph.
2236  Cycles are discovered, and calls into a cycle are made to share the time
2237 @@ -181,7 +185,7 @@
2238  @c man end
2239
2240  @c man begin SEEALSO
2241 -monitor(3), profil(2), cc(1), prof(1), and the Info entry for @file{gprof}.
2242 +profil(2), cc(1), prof(1), and the Info entry for @file{gprof}.
2243
2244  ``An Execution Profiler for Modular Programs'',
2245  by S. Graham, P. Kessler, M. McKusick;
2246 @@ -267,6 +271,11 @@
2247  options.  The same option, @samp{-pg}, alters either compilation or linking
2248  to do what is necessary for profiling.  Here are examples:
2249
2250 +If you use gcc 2.95.x or 3.0.x, you may need to add the
2251 +@samp{-fprofile-arcs} option to the compile line along with @samp{-pg}
2252 +in order to allow the call-graphs to be properly included in the gmon.out
2253 +file.
2254 +
2255  @example
2256  cc -g -c myprog.c utils.c -pg
2257  cc -o myprog myprog.o utils.o -pg
2258 diff -urN binutils-2.14.90.0.7.orig/ld/Makefile.am binutils-2.14.90.0.7/ld/Makefile.am
2259 --- binutils-2.14.90.0.7.orig/ld/Makefile.am    2003-10-29 10:37:48.000000000 -0700
2260 +++ binutils-2.14.90.0.7/ld/Makefile.am 2004-04-20 01:26:11.000000000 -0600
2261 @@ -19,7 +19,7 @@
2262  # We put the scripts in the directory $(scriptdir)/ldscripts.
2263  # We can't put the scripts in $(datadir) because the SEARCH_DIR
2264  # directives need to be different for native and cross linkers.
2265 -scriptdir = $(tooldir)/lib
2266 +scriptdir = $(libdir)
2267
2268  EMUL = @EMUL@
2269  EMULATION_OFILES = @EMULATION_OFILES@
2270 diff -urN binutils-2.14.90.0.7.orig/ld/Makefile.in binutils-2.14.90.0.7/ld/Makefile.in
2271 --- binutils-2.14.90.0.7.orig/ld/Makefile.in    2003-10-29 10:37:48.000000000 -0700
2272 +++ binutils-2.14.90.0.7/ld/Makefile.in 2004-04-20 01:26:11.000000000 -0600
2273 @@ -128,7 +128,7 @@
2274  # We put the scripts in the directory $(scriptdir)/ldscripts.
2275  # We can't put the scripts in $(datadir) because the SEARCH_DIR
2276  # directives need to be different for native and cross linkers.
2277 -scriptdir = $(tooldir)/lib
2278 +scriptdir = $(libdir)
2279
2280  EMUL = @EMUL@
2281  EMULATION_OFILES = @EMULATION_OFILES@
2282 diff -urN binutils-2.14.90.0.7.orig/ld/emultempl/elf32.em binutils-2.14.90.0.7/ld/emultempl/elf32.em
2283 --- binutils-2.14.90.0.7.orig/ld/emultempl/elf32.em     2003-08-21 09:28:48.000000000 -0600
2284 +++ binutils-2.14.90.0.7/ld/emultempl/elf32.em  2004-04-20 01:26:11.000000000 -0600
2285 @@ -679,6 +679,8 @@
2286               && command_line.rpath == NULL)
2287             {
2288               lib_path = (const char *) getenv ("LD_RUN_PATH");
2289 +             if ((lib_path) && (strlen (lib_path) == 0))
2290 +                 lib_path = NULL;
2291               if (gld${EMULATION_NAME}_search_needed (lib_path, l->name,
2292                                                       force))
2293                 break;
2294 @@ -855,6 +857,8 @@
2295    rpath = command_line.rpath;
2296    if (rpath == NULL)
2297      rpath = (const char *) getenv ("LD_RUN_PATH");
2298 +  if ((rpath) && (strlen (rpath) == 0))
2299 +      rpath = NULL;
2300    if (! (bfd_elf${ELFSIZE}_size_dynamic_sections
2301          (output_bfd, command_line.soname, rpath,
2302           command_line.filter_shlib,
2303 diff -urN binutils-2.14.90.0.7.orig/ltmain.sh binutils-2.14.90.0.7/ltmain.sh
2304 --- binutils-2.14.90.0.7.orig/ltmain.sh 2002-03-22 15:06:16.000000000 -0700
2305 +++ binutils-2.14.90.0.7/ltmain.sh      2004-04-20 01:26:12.000000000 -0600
2306 @@ -4413,6 +4413,10 @@
2307        # LD_LIBRARY_PATH before the program is installed.
2308        $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
2309        $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
2310 +      if test -n "$linkname"; then
2311 +        $show "(cd $output_objdir && $rm ../$linkname && $LN_S $output_objdir/$linkname ../$linkname)"
2312 +        $run eval '(cd $output_objdir && $rm ../$linkname && $LN_S $output_objdir/$linkname ../$linkname)' || exit $?
2313 +      fi
2314        ;;
2315      esac
2316      exit 0
2317 diff -urN binutils-2.14.90.0.7.orig/opcodes/Makefile.am binutils-2.14.90.0.7/opcodes/Makefile.am
2318 --- binutils-2.14.90.0.7.orig/opcodes/Makefile.am       2003-10-29 10:37:49.000000000 -0700
2319 +++ binutils-2.14.90.0.7/opcodes/Makefile.am    2004-04-20 01:26:12.000000000 -0600
2320 @@ -284,7 +284,7 @@
2321
2322  libopcodes_la_SOURCES =  dis-buf.c disassemble.c dis-init.c
2323  libopcodes_la_DEPENDENCIES = $(OFILES) ../bfd/libbfd.la
2324 -libopcodes_la_LIBADD = $(OFILES) @WIN32LIBADD@ ../bfd/libbfd.la
2325 +libopcodes_la_LIBADD = $(OFILES) @WIN32LIBADD@ -L../bfd -lbfd
2326  libopcodes_la_LDFLAGS = -release $(VERSION) @WIN32LDFLAGS@
2327
2328  # libtool will build .libs/libopcodes.a.  We create libopcodes.a in
2329 diff -urN binutils-2.14.90.0.7.orig/opcodes/Makefile.in binutils-2.14.90.0.7/opcodes/Makefile.in
2330 --- binutils-2.14.90.0.7.orig/opcodes/Makefile.in       2003-10-29 10:37:49.000000000 -0700
2331 +++ binutils-2.14.90.0.7/opcodes/Makefile.in    2004-04-20 01:26:12.000000000 -0600
2332 @@ -394,7 +394,7 @@
2333
2334  libopcodes_la_SOURCES = dis-buf.c disassemble.c dis-init.c
2335  libopcodes_la_DEPENDENCIES = $(OFILES) ../bfd/libbfd.la
2336 -libopcodes_la_LIBADD = $(OFILES) @WIN32LIBADD@ ../bfd/libbfd.la
2337 +libopcodes_la_LIBADD = $(OFILES) @WIN32LIBADD@ -L../bfd -lbfd
2338  libopcodes_la_LDFLAGS = -release $(VERSION) @WIN32LDFLAGS@
2339
2340  # libtool will build .libs/libopcodes.a.  We create libopcodes.a in
2341 @@ -593,7 +593,7 @@
2342  all-recursive install-data-recursive install-exec-recursive \
2343  installdirs-recursive install-recursive uninstall-recursive install-info-recursive \
2344  check-recursive installcheck-recursive info-recursive dvi-recursive:
2345 -       @set fnord $(MAKEFLAGS); amf=$$2; \
2346 +       @set fnord $$MAKEFLAGS; amf=$$2; \
2347         dot_seen=no; \
2348         target=`echo $@ | sed s/-recursive//`; \
2349         list='$(SUBDIRS)'; for subdir in $$list; do \
2350 @@ -613,7 +613,7 @@
2351
2352  mostlyclean-recursive clean-recursive distclean-recursive \
2353  maintainer-clean-recursive:
2354 -       @set fnord $(MAKEFLAGS); amf=$$2; \
2355 +       @set fnord $$MAKEFLAGS; amf=$$2; \
2356         dot_seen=no; \
2357         rev=''; list='$(SUBDIRS)'; for subdir in $$list; do \
2358           rev="$$subdir $$rev"; \
2359 diff -urN binutils-2.14.90.0.7.orig/opcodes/alpha-opc.c binutils-2.14.90.0.7/opcodes/alpha-opc.c
2360 --- binutils-2.14.90.0.7.orig/opcodes/alpha-opc.c       2003-01-21 11:21:34.000000000 -0700
2361 +++ binutils-2.14.90.0.7/opcodes/alpha-opc.c    2004-04-20 01:26:11.000000000 -0600
2362 @@ -1105,7 +1105,8 @@
2363    { "wmb",             MFC(0x18,0x4400), BASE, ARG_NONE },
2364    { "fetch",           MFC(0x18,0x8000), BASE, { ZA, PRB } },
2365    { "fetch_m",         MFC(0x18,0xA000), BASE, { ZA, PRB } },
2366 -  { "rpcc",            MFC(0x18,0xC000), BASE, { RA } },
2367 +  { "rpcc",            MFC(0x18,0xC000), BASE, { RA, ZB } },
2368 +  { "rpcc",            MFC(0x18,0xC000), BASE, { RA, RB } },   /* ev6 una */
2369    { "rc",              MFC(0x18,0xE000), BASE, { RA } },
2370    { "ecb",             MFC(0x18,0xE800), BASE, { ZA, PRB } },  /* ev56 una */
2371    { "rs",              MFC(0x18,0xF000), BASE, { RA } },
2372 diff -urN binutils-2.14.90.0.7.orig/opcodes/m68k-opc.c binutils-2.14.90.0.7/opcodes/m68k-opc.c
2373 --- binutils-2.14.90.0.7.orig/opcodes/m68k-opc.c        2003-10-29 10:37:49.000000000 -0700
2374 +++ binutils-2.14.90.0.7/opcodes/m68k-opc.c     2004-04-20 01:26:12.000000000 -0600
2375 @@ -847,15 +847,15 @@
2376  {"fmoved",     two(0xF000, 0x7400), two(0xF1C0, 0xFC7F), "IiF7ws", cfloat },
2377  {"fmovel",     two(0xF000, 0x4000), two(0xF1C0, 0xFC7F), "Ii;lF7", mfloat },
2378  {"fmovel",     two(0xF000, 0x6000), two(0xF1C0, 0xFC7F), "IiF7$l", mfloat },
2379 +/* FIXME: the next two variants should not permit moving an address
2380 +   register to anything but the floating point instruction register.  */
2381 +{"fmovel",     two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "Iis8%s", mfloat },
2382 +{"fmovel",     two(0xF000, 0x8000), two(0xF1C0, 0xE3FF), "Ii*ls8", mfloat },
2383  {"fmovel",     two(0xF000, 0x4000), two(0xF1C0, 0xFC7F), "IibsF7", cfloat },
2384  {"fmovel",     two(0xF000, 0x6000), two(0xF1C0, 0xFC7F), "IiF7bs", cfloat },
2385    /* Move the FP control registers */
2386  {"fmovel",     two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "Iis8ps", cfloat },
2387  {"fmovel",     two(0xF000, 0x8000), two(0xF1C0, 0xE3FF), "Iibss8", cfloat },
2388 -/* FIXME: the next two variants should not permit moving an address
2389 -   register to anything but the floating point instruction register.  */
2390 -{"fmovel",     two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "Iis8%s", mfloat },
2391 -{"fmovel",     two(0xF000, 0x8000), two(0xF1C0, 0xE3FF), "Ii*ls8", mfloat },
2392  {"fmovep",     two(0xF000, 0x4C00), two(0xF1C0, 0xFC7F), "Ii;pF7", mfloat },
2393  {"fmovep",     two(0xF000, 0x6C00), two(0xF1C0, 0xFC00), "IiF7~pkC", mfloat },
2394  {"fmovep",     two(0xF000, 0x7C00), two(0xF1C0, 0xFC0F), "IiF7~pDk", mfloat },