bfd/reloc.c

   1 /* BFD support for handling relocation entries.
   2    Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
   3    Free Software Foundation, Inc.
   4    Written by Cygnus Support.
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /*
  23 SECTION
  24         Relocations
  25
  26         BFD maintains relocations in much the same way it maintains
  27         symbols: they are left alone until required, then read in
  28         en-masse and translated into an internal form.  A common
  29         routine <<bfd_perform_relocation>> acts upon the
  30         canonical form to do the fixup.
  31
  32         Relocations are maintained on a per section basis,
  33         while symbols are maintained on a per BFD basis.
  34
  35         All that a back end has to do to fit the BFD interface is to create
  36         a <<struct reloc_cache_entry>> for each relocation
  37         in a particular section, and fill in the right bits of the structures.
  38
  39 @menu
  40 @* typedef arelent::
  41 @* howto manager::
  42 @end menu
  43
  44 */
  45
  46 /* DO compile in the reloc_code name table from libbfd.h.  */
  47 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
  48
  49 #include "bfd.h"
  50 #include "sysdep.h"
  51 #include "bfdlink.h"
  52 #include "libbfd.h"
  53 /*
  54 DOCDD
  55 INODE
  56         typedef arelent, howto manager, Relocations, Relocations
  57
  58 SUBSECTION
  59         typedef arelent
  60
  61         This is the structure of a relocation entry:
  62
  63 CODE_FRAGMENT
  64 .
  65 .typedef enum bfd_reloc_status
  66 .{
  67 .       {* No errors detected *}
  68 .  bfd_reloc_ok,
  69 .
  70 .       {* The relocation was performed, but there was an overflow. *}
  71 .  bfd_reloc_overflow,
  72 .
  73 .       {* The address to relocate was not within the section supplied. *}
  74 .  bfd_reloc_outofrange,
  75 .
  76 .       {* Used by special functions *}
  77 .  bfd_reloc_continue,
  78 .
  79 .       {* Unsupported relocation size requested. *}
  80 .  bfd_reloc_notsupported,
  81 .
  82 .       {* Unused *}
  83 .  bfd_reloc_other,
  84 .
  85 .       {* The symbol to relocate against was undefined. *}
  86 .  bfd_reloc_undefined,
  87 .
  88 .       {* The relocation was performed, but may not be ok - presently
  89 .          generated only when linking i960 coff files with i960 b.out
  90 .          symbols.  If this type is returned, the error_message argument
  91 .          to bfd_perform_relocation will be set.  *}
  92 .  bfd_reloc_dangerous
  93 . }
  94 . bfd_reloc_status_type;
  95 .
  96 .
  97 .typedef struct reloc_cache_entry
  98 .{
  99 .       {* A pointer into the canonical table of pointers  *}
 100 .  struct symbol_cache_entry **sym_ptr_ptr;
 101 .
 102 .       {* offset in section *}
 103 .  bfd_size_type address;
 104 .
 105 .       {* addend for relocation value *}
 106 .  bfd_vma addend;
 107 .
 108 .       {* Pointer to how to perform the required relocation *}
 109 .  reloc_howto_type *howto;
 110 .
 111 .} arelent;
 112
 113 */
 114
 115 /*
 116 DESCRIPTION
 117
 118         Here is a description of each of the fields within an <<arelent>>:
 119
 120         o <<sym_ptr_ptr>>
 121
 122         The symbol table pointer points to a pointer to the symbol
 123         associated with the relocation request.  It is
 124         the pointer into the table returned by the back end's
 125         <<get_symtab>> action. @xref{Symbols}. The symbol is referenced
 126         through a pointer to a pointer so that tools like the linker
 127         can fix up all the symbols of the same name by modifying only
 128         one pointer. The relocation routine looks in the symbol and
 129         uses the base of the section the symbol is attached to and the
 130         value of the symbol as the initial relocation offset. If the
 131         symbol pointer is zero, then the section provided is looked up.
 132
 133         o <<address>>
 134
 135         The <<address>> field gives the offset in bytes from the base of
 136         the section data which owns the relocation record to the first
 137         byte of relocatable information. The actual data relocated
 138         will be relative to this point; for example, a relocation
 139         type which modifies the bottom two bytes of a four byte word
 140         would not touch the first byte pointed to in a big endian
 141         world.
 142
 143         o <<addend>>
 144
 145         The <<addend>> is a value provided by the back end to be added (!)
 146         to the relocation offset. Its interpretation is dependent upon
 147         the howto. For example, on the 68k the code:
 148
 149 |        char foo[];
 150 |        main()
 151 |                {
 152 |                return foo[0x12345678];
 153 |                }
 154
 155         Could be compiled into:
 156
 157 |        linkw fp,#-4
 158 |        moveb @@#12345678,d0
 159 |        extbl d0
 160 |        unlk fp
 161 |        rts
 162
 163         This could create a reloc pointing to <<foo>>, but leave the
 164         offset in the data, something like:
 165
 166 |RELOCATION RECORDS FOR [.text]:
 167 |offset   type      value
 168 |00000006 32        _foo
 169 |
 170 |00000000 4e56 fffc          ; linkw fp,#-4
 171 |00000004 1039 1234 5678     ; moveb @@#12345678,d0
 172 |0000000a 49c0               ; extbl d0
 173 |0000000c 4e5e               ; unlk fp
 174 |0000000e 4e75               ; rts
 175
 176         Using coff and an 88k, some instructions don't have enough
 177         space in them to represent the full address range, and
 178         pointers have to be loaded in two parts. So you'd get something like:
 179
 180 |        or.u     r13,r0,hi16(_foo+0x12345678)
 181 |        ld.b     r2,r13,lo16(_foo+0x12345678)
 182 |        jmp      r1
 183
 184         This should create two relocs, both pointing to <<_foo>>, and with
 185         0x12340000 in their addend field. The data would consist of:
 186
 187 |RELOCATION RECORDS FOR [.text]:
 188 |offset   type      value
 189 |00000002 HVRT16    _foo+0x12340000
 190 |00000006 LVRT16    _foo+0x12340000
 191 |
 192 |00000000 5da05678           ; or.u r13,r0,0x5678
 193 |00000004 1c4d5678           ; ld.b r2,r13,0x5678
 194 |00000008 f400c001           ; jmp r1
 195
 196         The relocation routine digs out the value from the data, adds
 197         it to the addend to get the original offset, and then adds the
 198         value of <<_foo>>. Note that all 32 bits have to be kept around
 199         somewhere, to cope with carry from bit 15 to bit 16.
 200
 201         One further example is the sparc and the a.out format. The
 202         sparc has a similar problem to the 88k, in that some
 203         instructions don't have room for an entire offset, but on the
 204         sparc the parts are created in odd sized lumps. The designers of
 205         the a.out format chose to not use the data within the section
 206         for storing part of the offset; all the offset is kept within
 207         the reloc. Anything in the data should be ignored.
 208
 209 |        save %sp,-112,%sp
 210 |        sethi %hi(_foo+0x12345678),%g2
 211 |        ldsb [%g2+%lo(_foo+0x12345678)],%i0
 212 |        ret
 213 |        restore
 214
 215         Both relocs contain a pointer to <<foo>>, and the offsets
 216         contain junk.
 217
 218 |RELOCATION RECORDS FOR [.text]:
 219 |offset   type      value
 220 |00000004 HI22      _foo+0x12345678
 221 |00000008 LO10      _foo+0x12345678
 222 |
 223 |00000000 9de3bf90     ; save %sp,-112,%sp
 224 |00000004 05000000     ; sethi %hi(_foo+0),%g2
 225 |00000008 f048a000     ; ldsb [%g2+%lo(_foo+0)],%i0
 226 |0000000c 81c7e008     ; ret
 227 |00000010 81e80000     ; restore
 228
 229         o <<howto>>
 230
 231         The <<howto>> field can be imagined as a
 232         relocation instruction. It is a pointer to a structure which
 233         contains information on what to do with all of the other
 234         information in the reloc record and data section. A back end
 235         would normally have a relocation instruction set and turn
 236         relocations into pointers to the correct structure on input -
 237         but it would be possible to create each howto field on demand.
 238
 239 */
 240
 241 /*
 242 SUBSUBSECTION
 243         <<enum complain_overflow>>
 244
 245         Indicates what sort of overflow checking should be done when
 246         performing a relocation.
 247
 248 CODE_FRAGMENT
 249 .
 250 .enum complain_overflow
 251 .{
 252 .       {* Do not complain on overflow. *}
 253 .  complain_overflow_dont,
 254 .
 255 .       {* Complain if the bitfield overflows, whether it is considered
 256 .          as signed or unsigned. *}
 257 .  complain_overflow_bitfield,
 258 .
 259 .       {* Complain if the value overflows when considered as signed
 260 .          number. *}
 261 .  complain_overflow_signed,
 262 .
 263 .       {* Complain if the value overflows when considered as an
 264 .          unsigned number. *}
 265 .  complain_overflow_unsigned
 266 .};
 267
 268 */
 269
 270 /*
 271 SUBSUBSECTION
 272         <<reloc_howto_type>>
 273
 274         The <<reloc_howto_type>> is a structure which contains all the
 275         information that libbfd needs to know to tie up a back end's data.
 276
 277 CODE_FRAGMENT
 278 .struct symbol_cache_entry;             {* Forward declaration *}
 279 .
 280 .struct reloc_howto_struct
 281 .{
 282 .       {*  The type field has mainly a documentary use - the back end can
 283 .           do what it wants with it, though normally the back end's
 284 .           external idea of what a reloc number is stored
 285 .           in this field. For example, a PC relative word relocation
 286 .           in a coff environment has the type 023 - because that's
 287 .           what the outside world calls a R_PCRWORD reloc. *}
 288 .  unsigned int type;
 289 .
 290 .       {*  The value the final relocation is shifted right by. This drops
 291 .           unwanted data from the relocation.  *}
 292 .  unsigned int rightshift;
 293 .
 294 .       {*  The size of the item to be relocated.  This is *not* a
 295 .           power-of-two measure.  To get the number of bytes operated
 296 .           on by a type of relocation, use bfd_get_reloc_size.  *}
 297 .  int size;
 298 .
 299 .       {*  The number of bits in the item to be relocated.  This is used
 300 .           when doing overflow checking.  *}
 301 .  unsigned int bitsize;
 302 .
 303 .       {*  Notes that the relocation is relative to the location in the
 304 .           data section of the addend. The relocation function will
 305 .           subtract from the relocation value the address of the location
 306 .           being relocated. *}
 307 .  boolean pc_relative;
 308 .
 309 .       {*  The bit position of the reloc value in the destination.
 310 .           The relocated value is left shifted by this amount. *}
 311 .  unsigned int bitpos;
 312 .
 313 .       {* What type of overflow error should be checked for when
 314 .          relocating. *}
 315 .  enum complain_overflow complain_on_overflow;
 316 .
 317 .       {* If this field is non null, then the supplied function is
 318 .          called rather than the normal function. This allows really
 319 .          strange relocation methods to be accomodated (e.g., i960 callj
 320 .          instructions). *}
 321 .  bfd_reloc_status_type (*special_function)
 322 .                                   PARAMS ((bfd *abfd,
 323 .                                            arelent *reloc_entry,
 324 .                                            struct symbol_cache_entry *symbol,
 325 .                                            PTR data,
 326 .                                            asection *input_section,
 327 .                                            bfd *output_bfd,
 328 .                                            char **error_message));
 329 .
 330 .       {* The textual name of the relocation type. *}
 331 .  char *name;
 332 .
 333 .       {* Some formats record a relocation addend in the section contents
 334 .          rather than with the relocation.  For ELF formats this is the
 335 .          distinction between USE_REL and USE_RELA (though the code checks
 336 .          for USE_REL == 1/0).  The value of this field is TRUE if the
 337 .          addend is recorded with the section contents; when performing a
 338 .          partial link (ld -r) the section contents (the data) will be
 339 .          modified.  The value of this field is FALSE if addends are
 340 .          recorded with the relocation (in arelent.addend); when performing
 341 .          a partial link the relocation will be modified.
 342 .          All relocations for all ELF USE_RELA targets should set this field
 343 .          to FALSE (values of TRUE should be looked on with suspicion).
 344 .          However, the converse is not true: not all relocations of all ELF
 345 .          USE_REL targets set this field to TRUE.  Why this is so is peculiar
 346 .          to each particular target.  For relocs that aren't used in partial
 347 .          links (e.g. GOT stuff) it doesn't matter what this is set to.  *}
 348 .  boolean partial_inplace;
 349 .
 350 .       {* The src_mask selects which parts of the read in data
 351 .          are to be used in the relocation sum.  E.g., if this was an 8 bit
 352 .          byte of data which we read and relocated, this would be
 353 .          0x000000ff. When we have relocs which have an addend, such as
 354 .          sun4 extended relocs, the value in the offset part of a
 355 .          relocating field is garbage so we never use it. In this case
 356 .          the mask would be 0x00000000. *}
 357 .  bfd_vma src_mask;
 358 .
 359 .       {* The dst_mask selects which parts of the instruction are replaced
 360 .          into the instruction. In most cases src_mask == dst_mask,
 361 .          except in the above special case, where dst_mask would be
 362 .          0x000000ff, and src_mask would be 0x00000000.   *}
 363 .  bfd_vma dst_mask;
 364 .
 365 .       {* When some formats create PC relative instructions, they leave
 366 .          the value of the pc of the place being relocated in the offset
 367 .          slot of the instruction, so that a PC relative relocation can
 368 .          be made just by adding in an ordinary offset (e.g., sun3 a.out).
 369 .          Some formats leave the displacement part of an instruction
 370 .          empty (e.g., m88k bcs); this flag signals the fact.*}
 371 .  boolean pcrel_offset;
 372 .
 373 .};
 374
 375 */
 376
 377 /*
 378 FUNCTION
 379         The HOWTO Macro
 380
 381 DESCRIPTION
 382         The HOWTO define is horrible and will go away.
 383
 384 .#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
 385 .  {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
 386
 387 DESCRIPTION
 388         And will be replaced with the totally magic way. But for the
 389         moment, we are compatible, so do it this way.
 390
 391 .#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
 392 .
 393
 394 DESCRIPTION
 395         This is used to fill in an empty howto entry in an array.
 396
 397 .#define EMPTY_HOWTO(C) \
 398 .  HOWTO((C),0,0,0,false,0,complain_overflow_dont,NULL,NULL,false,0,0,false)
 399 .
 400
 401 DESCRIPTION
 402         Helper routine to turn a symbol into a relocation value.
 403
 404 .#define HOWTO_PREPARE(relocation, symbol)      \
 405 .  {                                            \
 406 .  if (symbol != (asymbol *)NULL) {             \
 407 .    if (bfd_is_com_section (symbol->section)) { \
 408 .      relocation = 0;                          \
 409 .    }                                          \
 410 .    else {                                     \
 411 .      relocation = symbol->value;              \
 412 .    }                                          \
 413 .  }                                            \
 414 .}
 415
 416 */
 417
 418 /*
 419 FUNCTION
 420         bfd_get_reloc_size
 421
 422 SYNOPSIS
 423         unsigned int bfd_get_reloc_size (reloc_howto_type *);
 424
 425 DESCRIPTION
 426         For a reloc_howto_type that operates on a fixed number of bytes,
 427         this returns the number of bytes operated on.
 428  */
 429
 430 unsigned int
 431 bfd_get_reloc_size (howto)
 432      reloc_howto_type *howto;
 433 {
 434   switch (howto->size)
 435     {
 436     case 0: return 1;
 437     case 1: return 2;
 438     case 2: return 4;
 439     case 3: return 0;
 440     case 4: return 8;
 441     case 8: return 16;
 442     case -2: return 4;
 443     default: abort ();
 444     }
 445 }
 446
 447 /*
 448 TYPEDEF
 449         arelent_chain
 450
 451 DESCRIPTION
 452
 453         How relocs are tied together in an <<asection>>:
 454
 455 .typedef struct relent_chain {
 456 .  arelent relent;
 457 .  struct   relent_chain *next;
 458 .} arelent_chain;
 459
 460 */
 461
 462 /* N_ONES produces N one bits, without overflowing machine arithmetic.  */
 463 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
 464
 465 /*
 466 FUNCTION
 467         bfd_check_overflow
 468
 469 SYNOPSIS
 470         bfd_reloc_status_type
 471                 bfd_check_overflow
 472                         (enum complain_overflow how,
 473                          unsigned int bitsize,
 474                          unsigned int rightshift,
 475                          unsigned int addrsize,
 476                          bfd_vma relocation);
 477
 478 DESCRIPTION
 479         Perform overflow checking on @var{relocation} which has
 480         @var{bitsize} significant bits and will be shifted right by
 481         @var{rightshift} bits, on a machine with addresses containing
 482         @var{addrsize} significant bits.  The result is either of
 483         @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
 484
 485 */
 486
 487 bfd_reloc_status_type
 488 bfd_check_overflow (how, bitsize, rightshift, addrsize, relocation)
 489      enum complain_overflow how;
 490      unsigned int bitsize;
 491      unsigned int rightshift;
 492      unsigned int addrsize;
 493      bfd_vma relocation;
 494 {
 495   bfd_vma fieldmask, addrmask, signmask, ss, a;
 496   bfd_reloc_status_type flag = bfd_reloc_ok;
 497
 498   a = relocation;
 499
 500   /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
 501      we'll be permissive: extra bits in the field mask will
 502      automatically extend the address mask for purposes of the
 503      overflow check.  */
 504   fieldmask = N_ONES (bitsize);
 505   addrmask = N_ONES (addrsize) | fieldmask;
 506
 507   switch (how)
 508     {
 509     case complain_overflow_dont:
 510       break;
 511
 512     case complain_overflow_signed:
 513       /* If any sign bits are set, all sign bits must be set.  That
 514          is, A must be a valid negative address after shifting.  */
 515       a = (a & addrmask) >> rightshift;
 516       signmask = ~ (fieldmask >> 1);
 517       ss = a & signmask;
 518       if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
 519         flag = bfd_reloc_overflow;
 520       break;
 521
 522     case complain_overflow_unsigned:
 523       /* We have an overflow if the address does not fit in the field.  */
 524       a = (a & addrmask) >> rightshift;
 525       if ((a & ~ fieldmask) != 0)
 526         flag = bfd_reloc_overflow;
 527       break;
 528
 529     case complain_overflow_bitfield:
 530       /* Bitfields are sometimes signed, sometimes unsigned.  We
 531          explicitly allow an address wrap too, which means a bitfield
 532          of n bits is allowed to store -2**n to 2**n-1.  Thus overflow
 533          if the value has some, but not all, bits set outside the
 534          field.  */
 535       a >>= rightshift;
 536       ss = a & ~ fieldmask;
 537       if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & ~ fieldmask))
 538         flag = bfd_reloc_overflow;
 539       break;
 540
 541     default:
 542       abort ();
 543     }
 544
 545   return flag;
 546 }
 547
 548 /*
 549 FUNCTION
 550         bfd_perform_relocation
 551
 552 SYNOPSIS
 553         bfd_reloc_status_type
 554                 bfd_perform_relocation
 555                         (bfd *abfd,
 556                          arelent *reloc_entry,
 557                          PTR data,
 558                          asection *input_section,
 559                          bfd *output_bfd,
 560                          char **error_message);
 561
 562 DESCRIPTION
 563         If @var{output_bfd} is supplied to this function, the
 564         generated image will be relocatable; the relocations are
 565         copied to the output file after they have been changed to
 566         reflect the new state of the world. There are two ways of
 567         reflecting the results of partial linkage in an output file:
 568         by modifying the output data in place, and by modifying the
 569         relocation record.  Some native formats (e.g., basic a.out and
 570         basic coff) have no way of specifying an addend in the
 571         relocation type, so the addend has to go in the output data.
 572         This is no big deal since in these formats the output data
 573         slot will always be big enough for the addend. Complex reloc
 574         types with addends were invented to solve just this problem.
 575         The @var{error_message} argument is set to an error message if
 576         this return @code{bfd_reloc_dangerous}.
 577
 578 */
 579
 580 bfd_reloc_status_type
 581 bfd_perform_relocation (abfd, reloc_entry, data, input_section, output_bfd,
 582                         error_message)
 583      bfd *abfd;
 584      arelent *reloc_entry;
 585      PTR data;
 586      asection *input_section;
 587      bfd *output_bfd;
 588      char **error_message;
 589 {
 590   bfd_vma relocation;
 591   bfd_reloc_status_type flag = bfd_reloc_ok;
 592   bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
 593   bfd_vma output_base = 0;
 594   reloc_howto_type *howto = reloc_entry->howto;
 595   asection *reloc_target_output_section;
 596   asymbol *symbol;
 597
 598   symbol = *(reloc_entry->sym_ptr_ptr);
 599   if (bfd_is_abs_section (symbol->section)
 600       && output_bfd != (bfd *) NULL)
 601     {
 602       reloc_entry->address += input_section->output_offset;
 603       return bfd_reloc_ok;
 604     }
 605
 606   /* If we are not producing relocateable output, return an error if
 607      the symbol is not defined.  An undefined weak symbol is
 608      considered to have a value of zero (SVR4 ABI, p. 4-27).  */
 609   if (bfd_is_und_section (symbol->section)
 610       && (symbol->flags & BSF_WEAK) == 0
 611       && output_bfd == (bfd *) NULL)
 612     flag = bfd_reloc_undefined;
 613
 614   /* If there is a function supplied to handle this relocation type,
 615      call it.  It'll return `bfd_reloc_continue' if further processing
 616      can be done.  */
 617   if (howto->special_function)
 618     {
 619       bfd_reloc_status_type cont;
 620       cont = howto->special_function (abfd, reloc_entry, symbol, data,
 621                                       input_section, output_bfd,
 622                                       error_message);
 623       if (cont != bfd_reloc_continue)
 624         return cont;
 625     }
 626
 627   /* Is the address of the relocation really within the section?  */
 628   if (reloc_entry->address > input_section->_cooked_size /
 629       bfd_octets_per_byte (abfd))
 630     return bfd_reloc_outofrange;
 631
 632   /* Work out which section the relocation is targetted at and the
 633      initial relocation command value.  */
 634
 635   /* Get symbol value.  (Common symbols are special.)  */
 636   if (bfd_is_com_section (symbol->section))
 637     relocation = 0;
 638   else
 639     relocation = symbol->value;
 640
 641   reloc_target_output_section = symbol->section->output_section;
 642
 643   /* Convert input-section-relative symbol value to absolute.  */
 644   if (output_bfd && howto->partial_inplace == false)
 645     output_base = 0;
 646   else
 647     output_base = reloc_target_output_section->vma;
 648
 649   relocation += output_base + symbol->section->output_offset;
 650
 651   /* Add in supplied addend.  */
 652   relocation += reloc_entry->addend;
 653
 654   /* Here the variable relocation holds the final address of the
 655      symbol we are relocating against, plus any addend.  */
 656
 657   if (howto->pc_relative == true)
 658     {
 659       /* This is a PC relative relocation.  We want to set RELOCATION
 660          to the distance between the address of the symbol and the
 661          location.  RELOCATION is already the address of the symbol.
 662
 663          We start by subtracting the address of the section containing
 664          the location.
 665
 666          If pcrel_offset is set, we must further subtract the position
 667          of the location within the section.  Some targets arrange for
 668          the addend to be the negative of the position of the location
 669          within the section; for example, i386-aout does this.  For
 670          i386-aout, pcrel_offset is false.  Some other targets do not
 671          include the position of the location; for example, m88kbcs,
 672          or ELF.  For those targets, pcrel_offset is true.
 673
 674          If we are producing relocateable output, then we must ensure
 675          that this reloc will be correctly computed when the final
 676          relocation is done.  If pcrel_offset is false we want to wind
 677          up with the negative of the location within the section,
 678          which means we must adjust the existing addend by the change
 679          in the location within the section.  If pcrel_offset is true
 680          we do not want to adjust the existing addend at all.
 681
 682          FIXME: This seems logical to me, but for the case of
 683          producing relocateable output it is not what the code
 684          actually does.  I don't want to change it, because it seems
 685          far too likely that something will break.  */
 686
 687       relocation -=
 688         input_section->output_section->vma + input_section->output_offset;
 689
 690       if (howto->pcrel_offset == true)
 691         relocation -= reloc_entry->address;
 692     }
 693
 694   if (output_bfd != (bfd *) NULL)
 695     {
 696       if (howto->partial_inplace == false)
 697         {
 698           /* This is a partial relocation, and we want to apply the relocation
 699              to the reloc entry rather than the raw data. Modify the reloc
 700              inplace to reflect what we now know.  */
 701           reloc_entry->addend = relocation;
 702           reloc_entry->address += input_section->output_offset;
 703           return flag;
 704         }
 705       else
 706         {
 707           /* This is a partial relocation, but inplace, so modify the
 708              reloc record a bit.
 709
 710              If we've relocated with a symbol with a section, change
 711              into a ref to the section belonging to the symbol.  */
 712
 713           reloc_entry->address += input_section->output_offset;
 714
 715           /* WTF?? */
 716           if (abfd->xvec->flavour == bfd_target_coff_flavour
 717               && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
 718               && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
 719             {
 720 #if 1
 721               /* For m68k-coff, the addend was being subtracted twice during
 722                  relocation with -r.  Removing the line below this comment
 723                  fixes that problem; see PR 2953.
 724
 725 However, Ian wrote the following, regarding removing the line below,
 726 which explains why it is still enabled:  --djm
 727
 728 If you put a patch like that into BFD you need to check all the COFF
 729 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
 730 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
 731 problem in a different way.  There may very well be a reason that the
 732 code works as it does.
 733
 734 Hmmm.  The first obvious point is that bfd_perform_relocation should
 735 not have any tests that depend upon the flavour.  It's seem like
 736 entirely the wrong place for such a thing.  The second obvious point
 737 is that the current code ignores the reloc addend when producing
 738 relocateable output for COFF.  That's peculiar.  In fact, I really
 739 have no idea what the point of the line you want to remove is.
 740
 741 A typical COFF reloc subtracts the old value of the symbol and adds in
 742 the new value to the location in the object file (if it's a pc
 743 relative reloc it adds the difference between the symbol value and the
 744 location).  When relocating we need to preserve that property.
 745
 746 BFD handles this by setting the addend to the negative of the old
 747 value of the symbol.  Unfortunately it handles common symbols in a
 748 non-standard way (it doesn't subtract the old value) but that's a
 749 different story (we can't change it without losing backward
 750 compatibility with old object files) (coff-i386 does subtract the old
 751 value, to be compatible with existing coff-i386 targets, like SCO).
 752
 753 So everything works fine when not producing relocateable output.  When
 754 we are producing relocateable output, logically we should do exactly
 755 what we do when not producing relocateable output.  Therefore, your
 756 patch is correct.  In fact, it should probably always just set
 757 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
 758 add the value into the object file.  This won't hurt the COFF code,
 759 which doesn't use the addend; I'm not sure what it will do to other
 760 formats (the thing to check for would be whether any formats both use
 761 the addend and set partial_inplace).
 762
 763 When I wanted to make coff-i386 produce relocateable output, I ran
 764 into the problem that you are running into: I wanted to remove that
 765 line.  Rather than risk it, I made the coff-i386 relocs use a special
 766 function; it's coff_i386_reloc in coff-i386.c.  The function
 767 specifically adds the addend field into the object file, knowing that
 768 bfd_perform_relocation is not going to.  If you remove that line, then
 769 coff-i386.c will wind up adding the addend field in twice.  It's
 770 trivial to fix; it just needs to be done.
 771
 772 The problem with removing the line is just that it may break some
 773 working code.  With BFD it's hard to be sure of anything.  The right
 774 way to deal with this is simply to build and test at least all the
 775 supported COFF targets.  It should be straightforward if time and disk
 776 space consuming.  For each target:
 777     1) build the linker
 778     2) generate some executable, and link it using -r (I would
 779        probably use paranoia.o and link against newlib/libc.a, which
 780        for all the supported targets would be available in
 781        /usr/cygnus/progressive/H-host/target/lib/libc.a).
 782     3) make the change to reloc.c
 783     4) rebuild the linker
 784     5) repeat step 2
 785     6) if the resulting object files are the same, you have at least
 786        made it no worse
 787     7) if they are different you have to figure out which version is
 788        right
 789 */
 790               relocation -= reloc_entry->addend;
 791 #endif
 792               reloc_entry->addend = 0;
 793             }
 794           else
 795             {
 796               reloc_entry->addend = relocation;
 797             }
 798         }
 799     }
 800   else
 801     {
 802       reloc_entry->addend = 0;
 803     }
 804
 805   /* FIXME: This overflow checking is incomplete, because the value
 806      might have overflowed before we get here.  For a correct check we
 807      need to compute the value in a size larger than bitsize, but we
 808      can't reasonably do that for a reloc the same size as a host
 809      machine word.
 810      FIXME: We should also do overflow checking on the result after
 811      adding in the value contained in the object file.  */
 812   if (howto->complain_on_overflow != complain_overflow_dont
 813       && flag == bfd_reloc_ok)
 814     flag = bfd_check_overflow (howto->complain_on_overflow,
 815                                howto->bitsize,
 816                                howto->rightshift,
 817                                bfd_arch_bits_per_address (abfd),
 818                                relocation);
 819
 820   /*
 821     Either we are relocating all the way, or we don't want to apply
 822     the relocation to the reloc entry (probably because there isn't
 823     any room in the output format to describe addends to relocs)
 824     */
 825
 826   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
 827      (OSF version 1.3, compiler version 3.11).  It miscompiles the
 828      following program:
 829
 830      struct str
 831      {
 832        unsigned int i0;
 833      } s = { 0 };
 834
 835      int
 836      main ()
 837      {
 838        unsigned long x;
 839
 840        x = 0x100000000;
 841        x <<= (unsigned long) s.i0;
 842        if (x == 0)
 843          printf ("failed\n");
 844        else
 845          printf ("succeeded (%lx)\n", x);
 846      }
 847      */
 848
 849   relocation >>= (bfd_vma) howto->rightshift;
 850
 851   /* Shift everything up to where it's going to be used */
 852
 853   relocation <<= (bfd_vma) howto->bitpos;
 854
 855   /* Wait for the day when all have the mask in them */
 856
 857   /* What we do:
 858      i instruction to be left alone
 859      o offset within instruction
 860      r relocation offset to apply
 861      S src mask
 862      D dst mask
 863      N ~dst mask
 864      A part 1
 865      B part 2
 866      R result
 867
 868      Do this:
 869      ((  i i i i i o o o o o  from bfd_get<size>
 870      and           S S S S S) to get the size offset we want
 871      +   r r r r r r r r r r) to get the final value to place
 872      and           D D D D D  to chop to right size
 873      -----------------------
 874      =             A A A A A
 875      And this:
 876      (   i i i i i o o o o o  from bfd_get<size>
 877      and N N N N N          ) get instruction
 878      -----------------------
 879      =   B B B B B
 880
 881      And then:
 882      (   B B B B B
 883      or            A A A A A)
 884      -----------------------
 885      =   R R R R R R R R R R  put into bfd_put<size>
 886      */
 887
 888 #define DOIT(x) \
 889   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
 890
 891   switch (howto->size)
 892     {
 893     case 0:
 894       {
 895         char x = bfd_get_8 (abfd, (char *) data + octets);
 896         DOIT (x);
 897         bfd_put_8 (abfd, x, (unsigned char *) data + octets);
 898       }
 899       break;
 900
 901     case 1:
 902       {
 903         short x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
 904         DOIT (x);
 905         bfd_put_16 (abfd, x, (unsigned char *) data + octets);
 906       }
 907       break;
 908     case 2:
 909       {
 910         long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
 911         DOIT (x);
 912         bfd_put_32 (abfd, x, (bfd_byte *) data + octets);
 913       }
 914       break;
 915     case -2:
 916       {
 917         long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
 918         relocation = -relocation;
 919         DOIT (x);
 920         bfd_put_32 (abfd, x, (bfd_byte *) data + octets);
 921       }
 922       break;
 923
 924     case -1:
 925       {
 926         long x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
 927         relocation = -relocation;
 928         DOIT (x);
 929         bfd_put_16 (abfd, x, (bfd_byte *) data + octets);
 930       }
 931       break;
 932
 933     case 3:
 934       /* Do nothing */
 935       break;
 936
 937     case 4:
 938 #ifdef BFD64
 939       {
 940         bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets);
 941         DOIT (x);
 942         bfd_put_64 (abfd, x, (bfd_byte *) data + octets);
 943       }
 944 #else
 945       abort ();
 946 #endif
 947       break;
 948     default:
 949       return bfd_reloc_other;
 950     }
 951
 952   return flag;
 953 }
 954
 955 /*
 956 FUNCTION
 957         bfd_install_relocation
 958
 959 SYNOPSIS
 960         bfd_reloc_status_type
 961                 bfd_install_relocation
 962                         (bfd *abfd,
 963                          arelent *reloc_entry,
 964                          PTR data, bfd_vma data_start,
 965                          asection *input_section,
 966                          char **error_message);
 967
 968 DESCRIPTION
 969         This looks remarkably like <<bfd_perform_relocation>>, except it
 970         does not expect that the section contents have been filled in.
 971         I.e., it's suitable for use when creating, rather than applying
 972         a relocation.
 973
 974         For now, this function should be considered reserved for the
 975         assembler.
 976
 977 */
 978
 979 bfd_reloc_status_type
 980 bfd_install_relocation (abfd, reloc_entry, data_start, data_start_offset,
 981                         input_section, error_message)
 982      bfd *abfd;
 983      arelent *reloc_entry;
 984      PTR data_start;
 985      bfd_vma data_start_offset;
 986      asection *input_section;
 987      char **error_message;
 988 {
 989   bfd_vma relocation;
 990   bfd_reloc_status_type flag = bfd_reloc_ok;
 991   bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
 992   bfd_vma output_base = 0;
 993   reloc_howto_type *howto = reloc_entry->howto;
 994   asection *reloc_target_output_section;
 995   asymbol *symbol;
 996   bfd_byte *data;
 997
 998   symbol = *(reloc_entry->sym_ptr_ptr);
 999   if (bfd_is_abs_section (symbol->section))
1000     {
1001       reloc_entry->address += input_section->output_offset;
1002       return bfd_reloc_ok;
1003     }
1004
1005   /* If there is a function supplied to handle this relocation type,
1006      call it.  It'll return `bfd_reloc_continue' if further processing
1007      can be done.  */
1008   if (howto->special_function)
1009     {
1010       bfd_reloc_status_type cont;
1011
1012       /* XXX - The special_function calls haven't been fixed up to deal
1013          with creating new relocations and section contents.  */
1014       cont = howto->special_function (abfd, reloc_entry, symbol,
1015                                       /* XXX - Non-portable! */
1016                                       ((bfd_byte *) data_start
1017                                        - data_start_offset),
1018                                       input_section, abfd, error_message);
1019       if (cont != bfd_reloc_continue)
1020         return cont;
1021     }
1022
1023   /* Is the address of the relocation really within the section?  */
1024   if (reloc_entry->address > input_section->_cooked_size)
1025     return bfd_reloc_outofrange;
1026
1027   /* Work out which section the relocation is targetted at and the
1028      initial relocation command value.  */
1029
1030   /* Get symbol value.  (Common symbols are special.)  */
1031   if (bfd_is_com_section (symbol->section))
1032     relocation = 0;
1033   else
1034     relocation = symbol->value;
1035
1036   reloc_target_output_section = symbol->section->output_section;
1037
1038   /* Convert input-section-relative symbol value to absolute.  */
1039   if (howto->partial_inplace == false)
1040     output_base = 0;
1041   else
1042     output_base = reloc_target_output_section->vma;
1043
1044   relocation += output_base + symbol->section->output_offset;
1045
1046   /* Add in supplied addend.  */
1047   relocation += reloc_entry->addend;
1048
1049   /* Here the variable relocation holds the final address of the
1050      symbol we are relocating against, plus any addend.  */
1051
1052   if (howto->pc_relative == true)
1053     {
1054       /* This is a PC relative relocation.  We want to set RELOCATION
1055          to the distance between the address of the symbol and the
1056          location.  RELOCATION is already the address of the symbol.
1057
1058          We start by subtracting the address of the section containing
1059          the location.
1060
1061          If pcrel_offset is set, we must further subtract the position
1062          of the location within the section.  Some targets arrange for
1063          the addend to be the negative of the position of the location
1064          within the section; for example, i386-aout does this.  For
1065          i386-aout, pcrel_offset is false.  Some other targets do not
1066          include the position of the location; for example, m88kbcs,
1067          or ELF.  For those targets, pcrel_offset is true.
1068
1069          If we are producing relocateable output, then we must ensure
1070          that this reloc will be correctly computed when the final
1071          relocation is done.  If pcrel_offset is false we want to wind
1072          up with the negative of the location within the section,
1073          which means we must adjust the existing addend by the change
1074          in the location within the section.  If pcrel_offset is true
1075          we do not want to adjust the existing addend at all.
1076
1077          FIXME: This seems logical to me, but for the case of
1078          producing relocateable output it is not what the code
1079          actually does.  I don't want to change it, because it seems
1080          far too likely that something will break.  */
1081
1082       relocation -=
1083         input_section->output_section->vma + input_section->output_offset;
1084
1085       if (howto->pcrel_offset == true && howto->partial_inplace == true)
1086         relocation -= reloc_entry->address;
1087     }
1088
1089   if (howto->partial_inplace == false)
1090     {
1091       /* This is a partial relocation, and we want to apply the relocation
1092          to the reloc entry rather than the raw data. Modify the reloc
1093          inplace to reflect what we now know.  */
1094       reloc_entry->addend = relocation;
1095       reloc_entry->address += input_section->output_offset;
1096       return flag;
1097     }
1098   else
1099     {
1100       /* This is a partial relocation, but inplace, so modify the
1101          reloc record a bit.
1102
1103          If we've relocated with a symbol with a section, change
1104          into a ref to the section belonging to the symbol.  */
1105
1106       reloc_entry->address += input_section->output_offset;
1107
1108       /* WTF?? */
1109       if (abfd->xvec->flavour == bfd_target_coff_flavour
1110           && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1111           && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1112         {
1113 #if 1
1114 /* For m68k-coff, the addend was being subtracted twice during
1115    relocation with -r.  Removing the line below this comment
1116    fixes that problem; see PR 2953.
1117
1118 However, Ian wrote the following, regarding removing the line below,
1119 which explains why it is still enabled:  --djm
1120
1121 If you put a patch like that into BFD you need to check all the COFF
1122 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
1123 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1124 problem in a different way.  There may very well be a reason that the
1125 code works as it does.
1126
1127 Hmmm.  The first obvious point is that bfd_install_relocation should
1128 not have any tests that depend upon the flavour.  It's seem like
1129 entirely the wrong place for such a thing.  The second obvious point
1130 is that the current code ignores the reloc addend when producing
1131 relocateable output for COFF.  That's peculiar.  In fact, I really
1132 have no idea what the point of the line you want to remove is.
1133
1134 A typical COFF reloc subtracts the old value of the symbol and adds in
1135 the new value to the location in the object file (if it's a pc
1136 relative reloc it adds the difference between the symbol value and the
1137 location).  When relocating we need to preserve that property.
1138
1139 BFD handles this by setting the addend to the negative of the old
1140 value of the symbol.  Unfortunately it handles common symbols in a
1141 non-standard way (it doesn't subtract the old value) but that's a
1142 different story (we can't change it without losing backward
1143 compatibility with old object files) (coff-i386 does subtract the old
1144 value, to be compatible with existing coff-i386 targets, like SCO).
1145
1146 So everything works fine when not producing relocateable output.  When
1147 we are producing relocateable output, logically we should do exactly
1148 what we do when not producing relocateable output.  Therefore, your
1149 patch is correct.  In fact, it should probably always just set
1150 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1151 add the value into the object file.  This won't hurt the COFF code,
1152 which doesn't use the addend; I'm not sure what it will do to other
1153 formats (the thing to check for would be whether any formats both use
1154 the addend and set partial_inplace).
1155
1156 When I wanted to make coff-i386 produce relocateable output, I ran
1157 into the problem that you are running into: I wanted to remove that
1158 line.  Rather than risk it, I made the coff-i386 relocs use a special
1159 function; it's coff_i386_reloc in coff-i386.c.  The function
1160 specifically adds the addend field into the object file, knowing that
1161 bfd_install_relocation is not going to.  If you remove that line, then
1162 coff-i386.c will wind up adding the addend field in twice.  It's
1163 trivial to fix; it just needs to be done.
1164
1165 The problem with removing the line is just that it may break some
1166 working code.  With BFD it's hard to be sure of anything.  The right
1167 way to deal with this is simply to build and test at least all the
1168 supported COFF targets.  It should be straightforward if time and disk
1169 space consuming.  For each target:
1170     1) build the linker
1171     2) generate some executable, and link it using -r (I would
1172        probably use paranoia.o and link against newlib/libc.a, which
1173        for all the supported targets would be available in
1174        /usr/cygnus/progressive/H-host/target/lib/libc.a).
1175     3) make the change to reloc.c
1176     4) rebuild the linker
1177     5) repeat step 2
1178     6) if the resulting object files are the same, you have at least
1179        made it no worse
1180     7) if they are different you have to figure out which version is
1181        right
1182 */
1183           relocation -= reloc_entry->addend;
1184 #endif
1185           reloc_entry->addend = 0;
1186         }
1187       else
1188         {
1189           reloc_entry->addend = relocation;
1190         }
1191     }
1192
1193   /* FIXME: This overflow checking is incomplete, because the value
1194      might have overflowed before we get here.  For a correct check we
1195      need to compute the value in a size larger than bitsize, but we
1196      can't reasonably do that for a reloc the same size as a host
1197      machine word.
1198      FIXME: We should also do overflow checking on the result after
1199      adding in the value contained in the object file.  */
1200   if (howto->complain_on_overflow != complain_overflow_dont)
1201     flag = bfd_check_overflow (howto->complain_on_overflow,
1202                                howto->bitsize,
1203                                howto->rightshift,
1204                                bfd_arch_bits_per_address (abfd),
1205                                relocation);
1206
1207   /*
1208     Either we are relocating all the way, or we don't want to apply
1209     the relocation to the reloc entry (probably because there isn't
1210     any room in the output format to describe addends to relocs)
1211     */
1212
1213   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1214      (OSF version 1.3, compiler version 3.11).  It miscompiles the
1215      following program:
1216
1217      struct str
1218      {
1219        unsigned int i0;
1220      } s = { 0 };
1221
1222      int
1223      main ()
1224      {
1225        unsigned long x;
1226
1227        x = 0x100000000;
1228        x <<= (unsigned long) s.i0;
1229        if (x == 0)
1230          printf ("failed\n");
1231        else
1232          printf ("succeeded (%lx)\n", x);
1233      }
1234      */
1235
1236   relocation >>= (bfd_vma) howto->rightshift;
1237
1238   /* Shift everything up to where it's going to be used */
1239
1240   relocation <<= (bfd_vma) howto->bitpos;
1241
1242   /* Wait for the day when all have the mask in them */
1243
1244   /* What we do:
1245      i instruction to be left alone
1246      o offset within instruction
1247      r relocation offset to apply
1248      S src mask
1249      D dst mask
1250      N ~dst mask
1251      A part 1
1252      B part 2
1253      R result
1254
1255      Do this:
1256      ((  i i i i i o o o o o  from bfd_get<size>
1257      and           S S S S S) to get the size offset we want
1258      +   r r r r r r r r r r) to get the final value to place
1259      and           D D D D D  to chop to right size
1260      -----------------------
1261      =             A A A A A
1262      And this:
1263      (   i i i i i o o o o o  from bfd_get<size>
1264      and N N N N N          ) get instruction
1265      -----------------------
1266      =   B B B B B
1267
1268      And then:
1269      (   B B B B B
1270      or            A A A A A)
1271      -----------------------
1272      =   R R R R R R R R R R  put into bfd_put<size>
1273      */
1274
1275 #define DOIT(x) \
1276   x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
1277
1278   data = (bfd_byte *) data_start + (octets - data_start_offset);
1279
1280   switch (howto->size)
1281     {
1282     case 0:
1283       {
1284         char x = bfd_get_8 (abfd, (char *) data);
1285         DOIT (x);
1286         bfd_put_8 (abfd, x, (unsigned char *) data);
1287       }
1288       break;
1289
1290     case 1:
1291       {
1292         short x = bfd_get_16 (abfd, (bfd_byte *) data);
1293         DOIT (x);
1294         bfd_put_16 (abfd, x, (unsigned char *) data);
1295       }
1296       break;
1297     case 2:
1298       {
1299         long x = bfd_get_32 (abfd, (bfd_byte *) data);
1300         DOIT (x);
1301         bfd_put_32 (abfd, x, (bfd_byte *) data);
1302       }
1303       break;
1304     case -2:
1305       {
1306         long x = bfd_get_32 (abfd, (bfd_byte *) data);
1307         relocation = -relocation;
1308         DOIT (x);
1309         bfd_put_32 (abfd, x, (bfd_byte *) data);
1310       }
1311       break;
1312
1313     case 3:
1314       /* Do nothing */
1315       break;
1316
1317     case 4:
1318       {
1319         bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data);
1320         DOIT (x);
1321         bfd_put_64 (abfd, x, (bfd_byte *) data);
1322       }
1323       break;
1324     default:
1325       return bfd_reloc_other;
1326     }
1327
1328   return flag;
1329 }
1330
1331 /* This relocation routine is used by some of the backend linkers.
1332    They do not construct asymbol or arelent structures, so there is no
1333    reason for them to use bfd_perform_relocation.  Also,
1334    bfd_perform_relocation is so hacked up it is easier to write a new
1335    function than to try to deal with it.
1336
1337    This routine does a final relocation.  Whether it is useful for a
1338    relocateable link depends upon how the object format defines
1339    relocations.
1340
1341    FIXME: This routine ignores any special_function in the HOWTO,
1342    since the existing special_function values have been written for
1343    bfd_perform_relocation.
1344
1345    HOWTO is the reloc howto information.
1346    INPUT_BFD is the BFD which the reloc applies to.
1347    INPUT_SECTION is the section which the reloc applies to.
1348    CONTENTS is the contents of the section.
1349    ADDRESS is the address of the reloc within INPUT_SECTION.
1350    VALUE is the value of the symbol the reloc refers to.
1351    ADDEND is the addend of the reloc.  */
1352
1353 bfd_reloc_status_type
1354 _bfd_final_link_relocate (howto, input_bfd, input_section, contents, address,
1355                           value, addend)
1356      reloc_howto_type *howto;
1357      bfd *input_bfd;
1358      asection *input_section;
1359      bfd_byte *contents;
1360      bfd_vma address;
1361      bfd_vma value;
1362      bfd_vma addend;
1363 {
1364   bfd_vma relocation;
1365
1366   /* Sanity check the address.  */
1367   if (address > input_section->_raw_size)
1368     return bfd_reloc_outofrange;
1369
1370   /* This function assumes that we are dealing with a basic relocation
1371      against a symbol.  We want to compute the value of the symbol to
1372      relocate to.  This is just VALUE, the value of the symbol, plus
1373      ADDEND, any addend associated with the reloc.  */
1374   relocation = value + addend;
1375
1376   /* If the relocation is PC relative, we want to set RELOCATION to
1377      the distance between the symbol (currently in RELOCATION) and the
1378      location we are relocating.  Some targets (e.g., i386-aout)
1379      arrange for the contents of the section to be the negative of the
1380      offset of the location within the section; for such targets
1381      pcrel_offset is false.  Other targets (e.g., m88kbcs or ELF)
1382      simply leave the contents of the section as zero; for such
1383      targets pcrel_offset is true.  If pcrel_offset is false we do not
1384      need to subtract out the offset of the location within the
1385      section (which is just ADDRESS).  */
1386   if (howto->pc_relative)
1387     {
1388       relocation -= (input_section->output_section->vma
1389                      + input_section->output_offset);
1390       if (howto->pcrel_offset)
1391         relocation -= address;
1392     }
1393
1394   return _bfd_relocate_contents (howto, input_bfd, relocation,
1395                                  contents + address);
1396 }
1397
1398 /* Relocate a given location using a given value and howto.  */
1399
1400 bfd_reloc_status_type
1401 _bfd_relocate_contents (howto, input_bfd, relocation, location)
1402      reloc_howto_type *howto;
1403      bfd *input_bfd;
1404      bfd_vma relocation;
1405      bfd_byte *location;
1406 {
1407   int size;
1408   bfd_vma x = 0;
1409   bfd_reloc_status_type flag;
1410   unsigned int rightshift = howto->rightshift;
1411   unsigned int bitpos = howto->bitpos;
1412
1413   /* If the size is negative, negate RELOCATION.  This isn't very
1414      general.  */
1415   if (howto->size < 0)
1416     relocation = -relocation;
1417
1418   /* Get the value we are going to relocate.  */
1419   size = bfd_get_reloc_size (howto);
1420   switch (size)
1421     {
1422     default:
1423     case 0:
1424       abort ();
1425     case 1:
1426       x = bfd_get_8 (input_bfd, location);
1427       break;
1428     case 2:
1429       x = bfd_get_16 (input_bfd, location);
1430       break;
1431     case 4:
1432       x = bfd_get_32 (input_bfd, location);
1433       break;
1434     case 8:
1435 #ifdef BFD64
1436       x = bfd_get_64 (input_bfd, location);
1437 #else
1438       abort ();
1439 #endif
1440       break;
1441     }
1442
1443   /* Check for overflow.  FIXME: We may drop bits during the addition
1444      which we don't check for.  We must either check at every single
1445      operation, which would be tedious, or we must do the computations
1446      in a type larger than bfd_vma, which would be inefficient.  */
1447   flag = bfd_reloc_ok;
1448   if (howto->complain_on_overflow != complain_overflow_dont)
1449     {
1450       bfd_vma addrmask, fieldmask, signmask, ss;
1451       bfd_vma a, b, sum;
1452
1453       /* Get the values to be added together.  For signed and unsigned
1454          relocations, we assume that all values should be truncated to
1455          the size of an address.  For bitfields, all the bits matter.
1456          See also bfd_check_overflow.  */
1457       fieldmask = N_ONES (howto->bitsize);
1458       addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
1459       a = relocation;
1460       b = x & howto->src_mask;
1461
1462       switch (howto->complain_on_overflow)
1463         {
1464         case complain_overflow_signed:
1465           a = (a & addrmask) >> rightshift;
1466
1467           /* If any sign bits are set, all sign bits must be set.
1468              That is, A must be a valid negative address after
1469              shifting.  */
1470           signmask = ~ (fieldmask >> 1);
1471           ss = a & signmask;
1472           if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
1473             flag = bfd_reloc_overflow;
1474
1475           /* We only need this next bit of code if the sign bit of B
1476              is below the sign bit of A.  This would only happen if
1477              SRC_MASK had fewer bits than BITSIZE.  Note that if
1478              SRC_MASK has more bits than BITSIZE, we can get into
1479              trouble; we would need to verify that B is in range, as
1480              we do for A above.  */
1481           signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1482
1483           /* Set all the bits above the sign bit.  */
1484           b = (b ^ signmask) - signmask;
1485
1486           b = (b & addrmask) >> bitpos;
1487
1488           /* Now we can do the addition.  */
1489           sum = a + b;
1490
1491           /* See if the result has the correct sign.  Bits above the
1492              sign bit are junk now; ignore them.  If the sum is
1493              positive, make sure we did not have all negative inputs;
1494              if the sum is negative, make sure we did not have all
1495              positive inputs.  The test below looks only at the sign
1496              bits, and it really just
1497                  SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1498              */
1499           signmask = (fieldmask >> 1) + 1;
1500           if (((~ (a ^ b)) & (a ^ sum)) & signmask)
1501             flag = bfd_reloc_overflow;
1502
1503           break;
1504
1505         case complain_overflow_unsigned:
1506           /* Checking for an unsigned overflow is relatively easy:
1507              trim the addresses and add, and trim the result as well.
1508              Overflow is normally indicated when the result does not
1509              fit in the field.  However, we also need to consider the
1510              case when, e.g., fieldmask is 0x7fffffff or smaller, an
1511              input is 0x80000000, and bfd_vma is only 32 bits; then we
1512              will get sum == 0, but there is an overflow, since the
1513              inputs did not fit in the field.  Instead of doing a
1514              separate test, we can check for this by or-ing in the
1515              operands when testing for the sum overflowing its final
1516              field.  */
1517           a = (a & addrmask) >> rightshift;
1518           b = (b & addrmask) >> bitpos;
1519           sum = (a + b) & addrmask;
1520           if ((a | b | sum) & ~ fieldmask)
1521             flag = bfd_reloc_overflow;
1522
1523           break;
1524
1525         case complain_overflow_bitfield:
1526           /* Much like the signed check, but for a field one bit
1527              wider, and no trimming inputs with addrmask.  We allow a
1528              bitfield to represent numbers in the range -2**n to
1529              2**n-1, where n is the number of bits in the field.
1530              Note that when bfd_vma is 32 bits, a 32-bit reloc can't
1531              overflow, which is exactly what we want.  */
1532           a >>= rightshift;
1533
1534           signmask = ~ fieldmask;
1535           ss = a & signmask;
1536           if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & signmask))
1537             flag = bfd_reloc_overflow;
1538
1539           signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1540           b = (b ^ signmask) - signmask;
1541
1542           b >>= bitpos;
1543
1544           sum = a + b;
1545
1546           /* We mask with addrmask here to explicitly allow an address
1547              wrap-around.  The Linux kernel relies on it, and it is
1548              the only way to write assembler code which can run when
1549              loaded at a location 0x80000000 away from the location at
1550              which it is linked.  */
1551           signmask = fieldmask + 1;
1552           if (((~ (a ^ b)) & (a ^ sum)) & signmask & addrmask)
1553             flag = bfd_reloc_overflow;
1554
1555           break;
1556
1557         default:
1558           abort ();
1559         }
1560     }
1561
1562   /* Put RELOCATION in the right bits.  */
1563   relocation >>= (bfd_vma) rightshift;
1564   relocation <<= (bfd_vma) bitpos;
1565
1566   /* Add RELOCATION to the right bits of X.  */
1567   x = ((x & ~howto->dst_mask)
1568        | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1569
1570   /* Put the relocated value back in the object file.  */
1571   switch (size)
1572     {
1573     default:
1574     case 0:
1575       abort ();
1576     case 1:
1577       bfd_put_8 (input_bfd, x, location);
1578       break;
1579     case 2:
1580       bfd_put_16 (input_bfd, x, location);
1581       break;
1582     case 4:
1583       bfd_put_32 (input_bfd, x, location);
1584       break;
1585     case 8:
1586 #ifdef BFD64
1587       bfd_put_64 (input_bfd, x, location);
1588 #else
1589       abort ();
1590 #endif
1591       break;
1592     }
1593
1594   return flag;
1595 }
1596
1597 /*
1598 DOCDD
1599 INODE
1600         howto manager,  , typedef arelent, Relocations
1601
1602 SECTION
1603         The howto manager
1604
1605         When an application wants to create a relocation, but doesn't
1606         know what the target machine might call it, it can find out by
1607         using this bit of code.
1608
1609 */
1610
1611 /*
1612 TYPEDEF
1613         bfd_reloc_code_type
1614
1615 DESCRIPTION
1616         The insides of a reloc code.  The idea is that, eventually, there
1617         will be one enumerator for every type of relocation we ever do.
1618         Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1619         return a howto pointer.
1620
1621         This does mean that the application must determine the correct
1622         enumerator value; you can't get a howto pointer from a random set
1623         of attributes.
1624
1625 SENUM
1626    bfd_reloc_code_real
1627
1628 ENUM
1629   BFD_RELOC_64
1630 ENUMX
1631   BFD_RELOC_32
1632 ENUMX
1633   BFD_RELOC_26
1634 ENUMX
1635   BFD_RELOC_24
1636 ENUMX
1637   BFD_RELOC_16
1638 ENUMX
1639   BFD_RELOC_14
1640 ENUMX
1641   BFD_RELOC_8
1642 ENUMDOC
1643   Basic absolute relocations of N bits.
1644
1645 ENUM
1646   BFD_RELOC_64_PCREL
1647 ENUMX
1648   BFD_RELOC_32_PCREL
1649 ENUMX
1650   BFD_RELOC_24_PCREL
1651 ENUMX
1652   BFD_RELOC_16_PCREL
1653 ENUMX
1654   BFD_RELOC_12_PCREL
1655 ENUMX
1656   BFD_RELOC_8_PCREL
1657 ENUMDOC
1658   PC-relative relocations.  Sometimes these are relative to the address
1659 of the relocation itself; sometimes they are relative to the start of
1660 the section containing the relocation.  It depends on the specific target.
1661
1662 The 24-bit relocation is used in some Intel 960 configurations.
1663
1664 ENUM
1665   BFD_RELOC_32_GOT_PCREL
1666 ENUMX
1667   BFD_RELOC_16_GOT_PCREL
1668 ENUMX
1669   BFD_RELOC_8_GOT_PCREL
1670 ENUMX
1671   BFD_RELOC_32_GOTOFF
1672 ENUMX
1673   BFD_RELOC_16_GOTOFF
1674 ENUMX
1675   BFD_RELOC_LO16_GOTOFF
1676 ENUMX
1677   BFD_RELOC_HI16_GOTOFF
1678 ENUMX
1679   BFD_RELOC_HI16_S_GOTOFF
1680 ENUMX
1681   BFD_RELOC_8_GOTOFF
1682 ENUMX
1683   BFD_RELOC_32_PLT_PCREL
1684 ENUMX
1685   BFD_RELOC_24_PLT_PCREL
1686 ENUMX
1687   BFD_RELOC_16_PLT_PCREL
1688 ENUMX
1689   BFD_RELOC_8_PLT_PCREL
1690 ENUMX
1691   BFD_RELOC_32_PLTOFF
1692 ENUMX
1693   BFD_RELOC_16_PLTOFF
1694 ENUMX
1695   BFD_RELOC_LO16_PLTOFF
1696 ENUMX
1697   BFD_RELOC_HI16_PLTOFF
1698 ENUMX
1699   BFD_RELOC_HI16_S_PLTOFF
1700 ENUMX
1701   BFD_RELOC_8_PLTOFF
1702 ENUMDOC
1703   For ELF.
1704
1705 ENUM
1706   BFD_RELOC_68K_GLOB_DAT
1707 ENUMX
1708   BFD_RELOC_68K_JMP_SLOT
1709 ENUMX
1710   BFD_RELOC_68K_RELATIVE
1711 ENUMDOC
1712   Relocations used by 68K ELF.
1713
1714 ENUM
1715   BFD_RELOC_32_BASEREL
1716 ENUMX
1717   BFD_RELOC_16_BASEREL
1718 ENUMX
1719   BFD_RELOC_LO16_BASEREL
1720 ENUMX
1721   BFD_RELOC_HI16_BASEREL
1722 ENUMX
1723   BFD_RELOC_HI16_S_BASEREL
1724 ENUMX
1725   BFD_RELOC_8_BASEREL
1726 ENUMX
1727   BFD_RELOC_RVA
1728 ENUMDOC
1729   Linkage-table relative.
1730
1731 ENUM
1732   BFD_RELOC_8_FFnn
1733 ENUMDOC
1734   Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1735
1736 ENUM
1737   BFD_RELOC_32_PCREL_S2
1738 ENUMX
1739   BFD_RELOC_16_PCREL_S2
1740 ENUMX
1741   BFD_RELOC_23_PCREL_S2
1742 ENUMDOC
1743   These PC-relative relocations are stored as word displacements --
1744 i.e., byte displacements shifted right two bits.  The 30-bit word
1745 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1746 SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
1747 signed 16-bit displacement is used on the MIPS, and the 23-bit
1748 displacement is used on the Alpha.
1749
1750 ENUM
1751   BFD_RELOC_HI22
1752 ENUMX
1753   BFD_RELOC_LO10
1754 ENUMDOC
1755   High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1756 the target word.  These are used on the SPARC.
1757
1758 ENUM
1759   BFD_RELOC_GPREL16
1760 ENUMX
1761   BFD_RELOC_GPREL32
1762 ENUMDOC
1763   For systems that allocate a Global Pointer register, these are
1764 displacements off that register.  These relocation types are
1765 handled specially, because the value the register will have is
1766 decided relatively late.
1767
1768 ENUM
1769   BFD_RELOC_I960_CALLJ
1770 ENUMDOC
1771   Reloc types used for i960/b.out.
1772
1773 ENUM
1774   BFD_RELOC_NONE
1775 ENUMX
1776   BFD_RELOC_SPARC_WDISP22
1777 ENUMX
1778   BFD_RELOC_SPARC22
1779 ENUMX
1780   BFD_RELOC_SPARC13
1781 ENUMX
1782   BFD_RELOC_SPARC_GOT10
1783 ENUMX
1784   BFD_RELOC_SPARC_GOT13
1785 ENUMX
1786   BFD_RELOC_SPARC_GOT22
1787 ENUMX
1788   BFD_RELOC_SPARC_PC10
1789 ENUMX
1790   BFD_RELOC_SPARC_PC22
1791 ENUMX
1792   BFD_RELOC_SPARC_WPLT30
1793 ENUMX
1794   BFD_RELOC_SPARC_COPY
1795 ENUMX
1796   BFD_RELOC_SPARC_GLOB_DAT
1797 ENUMX
1798   BFD_RELOC_SPARC_JMP_SLOT
1799 ENUMX
1800   BFD_RELOC_SPARC_RELATIVE
1801 ENUMX
1802   BFD_RELOC_SPARC_UA32
1803 ENUMDOC
1804   SPARC ELF relocations.  There is probably some overlap with other
1805   relocation types already defined.
1806
1807 ENUM
1808   BFD_RELOC_SPARC_BASE13
1809 ENUMX
1810   BFD_RELOC_SPARC_BASE22
1811 ENUMDOC
1812   I think these are specific to SPARC a.out (e.g., Sun 4).
1813
1814 ENUMEQ
1815   BFD_RELOC_SPARC_64
1816   BFD_RELOC_64
1817 ENUMX
1818   BFD_RELOC_SPARC_10
1819 ENUMX
1820   BFD_RELOC_SPARC_11
1821 ENUMX
1822   BFD_RELOC_SPARC_OLO10
1823 ENUMX
1824   BFD_RELOC_SPARC_HH22
1825 ENUMX
1826   BFD_RELOC_SPARC_HM10
1827 ENUMX
1828   BFD_RELOC_SPARC_LM22
1829 ENUMX
1830   BFD_RELOC_SPARC_PC_HH22
1831 ENUMX
1832   BFD_RELOC_SPARC_PC_HM10
1833 ENUMX
1834   BFD_RELOC_SPARC_PC_LM22
1835 ENUMX
1836   BFD_RELOC_SPARC_WDISP16
1837 ENUMX
1838   BFD_RELOC_SPARC_WDISP19
1839 ENUMX
1840   BFD_RELOC_SPARC_7
1841 ENUMX
1842   BFD_RELOC_SPARC_6
1843 ENUMX
1844   BFD_RELOC_SPARC_5
1845 ENUMEQX
1846   BFD_RELOC_SPARC_DISP64
1847   BFD_RELOC_64_PCREL
1848 ENUMX
1849   BFD_RELOC_SPARC_PLT64
1850 ENUMX
1851   BFD_RELOC_SPARC_HIX22
1852 ENUMX
1853   BFD_RELOC_SPARC_LOX10
1854 ENUMX
1855   BFD_RELOC_SPARC_H44
1856 ENUMX
1857   BFD_RELOC_SPARC_M44
1858 ENUMX
1859   BFD_RELOC_SPARC_L44
1860 ENUMX
1861   BFD_RELOC_SPARC_REGISTER
1862 ENUMDOC
1863   SPARC64 relocations
1864
1865 ENUM
1866   BFD_RELOC_SPARC_REV32
1867 ENUMDOC
1868   SPARC little endian relocation
1869
1870 ENUM
1871   BFD_RELOC_ALPHA_GPDISP_HI16
1872 ENUMDOC
1873   Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
1874      "addend" in some special way.
1875   For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1876      writing; when reading, it will be the absolute section symbol.  The
1877      addend is the displacement in bytes of the "lda" instruction from
1878      the "ldah" instruction (which is at the address of this reloc).
1879 ENUM
1880   BFD_RELOC_ALPHA_GPDISP_LO16
1881 ENUMDOC
1882   For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1883      with GPDISP_HI16 relocs.  The addend is ignored when writing the
1884      relocations out, and is filled in with the file's GP value on
1885      reading, for convenience.
1886
1887 ENUM
1888   BFD_RELOC_ALPHA_GPDISP
1889 ENUMDOC
1890   The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1891      relocation except that there is no accompanying GPDISP_LO16
1892      relocation.
1893
1894 ENUM
1895   BFD_RELOC_ALPHA_LITERAL
1896 ENUMX
1897   BFD_RELOC_ALPHA_ELF_LITERAL
1898 ENUMX
1899   BFD_RELOC_ALPHA_LITUSE
1900 ENUMDOC
1901   The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1902      the assembler turns it into a LDQ instruction to load the address of
1903      the symbol, and then fills in a register in the real instruction.
1904
1905      The LITERAL reloc, at the LDQ instruction, refers to the .lita
1906      section symbol.  The addend is ignored when writing, but is filled
1907      in with the file's GP value on reading, for convenience, as with the
1908      GPDISP_LO16 reloc.
1909
1910      The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1911      It should refer to the symbol to be referenced, as with 16_GOTOFF,
1912      but it generates output not based on the position within the .got
1913      section, but relative to the GP value chosen for the file during the
1914      final link stage.
1915
1916      The LITUSE reloc, on the instruction using the loaded address, gives
1917      information to the linker that it might be able to use to optimize
1918      away some literal section references.  The symbol is ignored (read
1919      as the absolute section symbol), and the "addend" indicates the type
1920      of instruction using the register:
1921               1 - "memory" fmt insn
1922               2 - byte-manipulation (byte offset reg)
1923               3 - jsr (target of branch)
1924
1925      The GNU linker currently doesn't do any of this optimizing.
1926
1927 ENUM
1928   BFD_RELOC_ALPHA_USER_LITERAL
1929 ENUMX
1930   BFD_RELOC_ALPHA_USER_LITUSE_BASE
1931 ENUMX
1932   BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF
1933 ENUMX
1934   BFD_RELOC_ALPHA_USER_LITUSE_JSR
1935 ENUMX
1936   BFD_RELOC_ALPHA_USER_GPDISP
1937 ENUMX
1938   BFD_RELOC_ALPHA_USER_GPRELHIGH
1939 ENUMX
1940   BFD_RELOC_ALPHA_USER_GPRELLOW
1941 ENUMDOC
1942   The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to
1943      process the explicit !<reloc>!sequence relocations, and are mapped
1944      into the normal relocations at the end of processing.
1945
1946 ENUM
1947   BFD_RELOC_ALPHA_HINT
1948 ENUMDOC
1949   The HINT relocation indicates a value that should be filled into the
1950      "hint" field of a jmp/jsr/ret instruction, for possible branch-
1951      prediction logic which may be provided on some processors.
1952
1953 ENUM
1954   BFD_RELOC_ALPHA_LINKAGE
1955 ENUMDOC
1956   The LINKAGE relocation outputs a linkage pair in the object file,
1957      which is filled by the linker.
1958
1959 ENUM
1960   BFD_RELOC_ALPHA_CODEADDR
1961 ENUMDOC
1962   The CODEADDR relocation outputs a STO_CA in the object file,
1963      which is filled by the linker.
1964
1965 ENUM
1966   BFD_RELOC_MIPS_JMP
1967 ENUMDOC
1968   Bits 27..2 of the relocation address shifted right 2 bits;
1969      simple reloc otherwise.
1970
1971 ENUM
1972   BFD_RELOC_MIPS16_JMP
1973 ENUMDOC
1974   The MIPS16 jump instruction.
1975
1976 ENUM
1977   BFD_RELOC_MIPS16_GPREL
1978 ENUMDOC
1979   MIPS16 GP relative reloc.
1980
1981 ENUM
1982   BFD_RELOC_HI16
1983 ENUMDOC
1984   High 16 bits of 32-bit value; simple reloc.
1985 ENUM
1986   BFD_RELOC_HI16_S
1987 ENUMDOC
1988   High 16 bits of 32-bit value but the low 16 bits will be sign
1989      extended and added to form the final result.  If the low 16
1990      bits form a negative number, we need to add one to the high value
1991      to compensate for the borrow when the low bits are added.
1992 ENUM
1993   BFD_RELOC_LO16
1994 ENUMDOC
1995   Low 16 bits.
1996 ENUM
1997   BFD_RELOC_PCREL_HI16_S
1998 ENUMDOC
1999   Like BFD_RELOC_HI16_S, but PC relative.
2000 ENUM
2001   BFD_RELOC_PCREL_LO16
2002 ENUMDOC
2003   Like BFD_RELOC_LO16, but PC relative.
2004
2005 ENUMEQ
2006   BFD_RELOC_MIPS_GPREL
2007   BFD_RELOC_GPREL16
2008 ENUMDOC
2009   Relocation relative to the global pointer.
2010
2011 ENUM
2012   BFD_RELOC_MIPS_LITERAL
2013 ENUMDOC
2014   Relocation against a MIPS literal section.
2015
2016 ENUM
2017   BFD_RELOC_MIPS_GOT16
2018 ENUMX
2019   BFD_RELOC_MIPS_CALL16
2020 ENUMEQX
2021   BFD_RELOC_MIPS_GPREL32
2022   BFD_RELOC_GPREL32
2023 ENUMX
2024   BFD_RELOC_MIPS_GOT_HI16
2025 ENUMX
2026   BFD_RELOC_MIPS_GOT_LO16
2027 ENUMX
2028   BFD_RELOC_MIPS_CALL_HI16
2029 ENUMX
2030   BFD_RELOC_MIPS_CALL_LO16
2031 ENUMX
2032   BFD_RELOC_MIPS_SUB
2033 ENUMX
2034   BFD_RELOC_MIPS_GOT_PAGE
2035 ENUMX
2036   BFD_RELOC_MIPS_GOT_OFST
2037 ENUMX
2038   BFD_RELOC_MIPS_GOT_DISP
2039 COMMENT
2040 ENUMDOC
2041   MIPS ELF relocations.
2042
2043 COMMENT
2044
2045 ENUM
2046   BFD_RELOC_386_GOT32
2047 ENUMX
2048   BFD_RELOC_386_PLT32
2049 ENUMX
2050   BFD_RELOC_386_COPY
2051 ENUMX
2052   BFD_RELOC_386_GLOB_DAT
2053 ENUMX
2054   BFD_RELOC_386_JUMP_SLOT
2055 ENUMX
2056   BFD_RELOC_386_RELATIVE
2057 ENUMX
2058   BFD_RELOC_386_GOTOFF
2059 ENUMX
2060   BFD_RELOC_386_GOTPC
2061 ENUMDOC
2062   i386/elf relocations
2063
2064 ENUM
2065   BFD_RELOC_X86_64_GOT32
2066 ENUMX
2067   BFD_RELOC_X86_64_PLT32
2068 ENUMX
2069   BFD_RELOC_X86_64_COPY
2070 ENUMX
2071   BFD_RELOC_X86_64_GLOB_DAT
2072 ENUMX
2073   BFD_RELOC_X86_64_JUMP_SLOT
2074 ENUMX
2075   BFD_RELOC_X86_64_RELATIVE
2076 ENUMX
2077   BFD_RELOC_X86_64_GOTPCREL
2078 ENUMX
2079   BFD_RELOC_X86_64_32S
2080 ENUMDOC
2081   x86-64/elf relocations
2082
2083 ENUM
2084   BFD_RELOC_NS32K_IMM_8
2085 ENUMX
2086   BFD_RELOC_NS32K_IMM_16
2087 ENUMX
2088   BFD_RELOC_NS32K_IMM_32
2089 ENUMX
2090   BFD_RELOC_NS32K_IMM_8_PCREL
2091 ENUMX
2092   BFD_RELOC_NS32K_IMM_16_PCREL
2093 ENUMX
2094   BFD_RELOC_NS32K_IMM_32_PCREL
2095 ENUMX
2096   BFD_RELOC_NS32K_DISP_8
2097 ENUMX
2098   BFD_RELOC_NS32K_DISP_16
2099 ENUMX
2100   BFD_RELOC_NS32K_DISP_32
2101 ENUMX
2102   BFD_RELOC_NS32K_DISP_8_PCREL
2103 ENUMX
2104   BFD_RELOC_NS32K_DISP_16_PCREL
2105 ENUMX
2106   BFD_RELOC_NS32K_DISP_32_PCREL
2107 ENUMDOC
2108   ns32k relocations
2109
2110 ENUM
2111   BFD_RELOC_PDP11_DISP_8_PCREL
2112 ENUMX
2113   BFD_RELOC_PDP11_DISP_6_PCREL
2114 ENUMDOC
2115   PDP11 relocations
2116
2117 ENUM
2118   BFD_RELOC_PJ_CODE_HI16
2119 ENUMX
2120   BFD_RELOC_PJ_CODE_LO16
2121 ENUMX
2122   BFD_RELOC_PJ_CODE_DIR16
2123 ENUMX
2124   BFD_RELOC_PJ_CODE_DIR32
2125 ENUMX
2126   BFD_RELOC_PJ_CODE_REL16
2127 ENUMX
2128   BFD_RELOC_PJ_CODE_REL32
2129 ENUMDOC
2130   Picojava relocs.  Not all of these appear in object files.
2131
2132 ENUM
2133   BFD_RELOC_PPC_B26
2134 ENUMX
2135   BFD_RELOC_PPC_BA26
2136 ENUMX
2137   BFD_RELOC_PPC_TOC16
2138 ENUMX
2139   BFD_RELOC_PPC_B16
2140 ENUMX
2141   BFD_RELOC_PPC_B16_BRTAKEN
2142 ENUMX
2143   BFD_RELOC_PPC_B16_BRNTAKEN
2144 ENUMX
2145   BFD_RELOC_PPC_BA16
2146 ENUMX
2147   BFD_RELOC_PPC_BA16_BRTAKEN
2148 ENUMX
2149   BFD_RELOC_PPC_BA16_BRNTAKEN
2150 ENUMX
2151   BFD_RELOC_PPC_COPY
2152 ENUMX
2153   BFD_RELOC_PPC_GLOB_DAT
2154 ENUMX
2155   BFD_RELOC_PPC_JMP_SLOT
2156 ENUMX
2157   BFD_RELOC_PPC_RELATIVE
2158 ENUMX
2159   BFD_RELOC_PPC_LOCAL24PC
2160 ENUMX
2161   BFD_RELOC_PPC_EMB_NADDR32
2162 ENUMX
2163   BFD_RELOC_PPC_EMB_NADDR16
2164 ENUMX
2165   BFD_RELOC_PPC_EMB_NADDR16_LO
2166 ENUMX
2167   BFD_RELOC_PPC_EMB_NADDR16_HI
2168 ENUMX
2169   BFD_RELOC_PPC_EMB_NADDR16_HA
2170 ENUMX
2171   BFD_RELOC_PPC_EMB_SDAI16
2172 ENUMX
2173   BFD_RELOC_PPC_EMB_SDA2I16
2174 ENUMX
2175   BFD_RELOC_PPC_EMB_SDA2REL
2176 ENUMX
2177   BFD_RELOC_PPC_EMB_SDA21
2178 ENUMX
2179   BFD_RELOC_PPC_EMB_MRKREF
2180 ENUMX
2181   BFD_RELOC_PPC_EMB_RELSEC16
2182 ENUMX
2183   BFD_RELOC_PPC_EMB_RELST_LO
2184 ENUMX
2185   BFD_RELOC_PPC_EMB_RELST_HI
2186 ENUMX
2187   BFD_RELOC_PPC_EMB_RELST_HA
2188 ENUMX
2189   BFD_RELOC_PPC_EMB_BIT_FLD
2190 ENUMX
2191   BFD_RELOC_PPC_EMB_RELSDA
2192 ENUMDOC
2193   Power(rs6000) and PowerPC relocations.
2194
2195 ENUM
2196   BFD_RELOC_I370_D12
2197 ENUMDOC
2198   IBM 370/390 relocations
2199
2200 ENUM
2201   BFD_RELOC_CTOR
2202 ENUMDOC
2203   The type of reloc used to build a contructor table - at the moment
2204   probably a 32 bit wide absolute relocation, but the target can choose.
2205   It generally does map to one of the other relocation types.
2206
2207 ENUM
2208   BFD_RELOC_ARM_PCREL_BRANCH
2209 ENUMDOC
2210   ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
2211   not stored in the instruction.
2212 ENUM
2213   BFD_RELOC_ARM_PCREL_BLX
2214 ENUMDOC
2215   ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
2216   not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2217   field in the instruction.
2218 ENUM
2219   BFD_RELOC_THUMB_PCREL_BLX
2220 ENUMDOC
2221   Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
2222   not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2223   field in the instruction.
2224 ENUM
2225   BFD_RELOC_ARM_IMMEDIATE
2226 ENUMX
2227   BFD_RELOC_ARM_ADRL_IMMEDIATE
2228 ENUMX
2229   BFD_RELOC_ARM_OFFSET_IMM
2230 ENUMX
2231   BFD_RELOC_ARM_SHIFT_IMM
2232 ENUMX
2233   BFD_RELOC_ARM_SWI
2234 ENUMX
2235   BFD_RELOC_ARM_MULTI
2236 ENUMX
2237   BFD_RELOC_ARM_CP_OFF_IMM
2238 ENUMX
2239   BFD_RELOC_ARM_ADR_IMM
2240 ENUMX
2241   BFD_RELOC_ARM_LDR_IMM
2242 ENUMX
2243   BFD_RELOC_ARM_LITERAL
2244 ENUMX
2245   BFD_RELOC_ARM_IN_POOL
2246 ENUMX
2247   BFD_RELOC_ARM_OFFSET_IMM8
2248 ENUMX
2249   BFD_RELOC_ARM_HWLITERAL
2250 ENUMX
2251   BFD_RELOC_ARM_THUMB_ADD
2252 ENUMX
2253   BFD_RELOC_ARM_THUMB_IMM
2254 ENUMX
2255   BFD_RELOC_ARM_THUMB_SHIFT
2256 ENUMX
2257   BFD_RELOC_ARM_THUMB_OFFSET
2258 ENUMX
2259   BFD_RELOC_ARM_GOT12
2260 ENUMX
2261   BFD_RELOC_ARM_GOT32
2262 ENUMX
2263   BFD_RELOC_ARM_JUMP_SLOT
2264 ENUMX
2265   BFD_RELOC_ARM_COPY
2266 ENUMX
2267   BFD_RELOC_ARM_GLOB_DAT
2268 ENUMX
2269   BFD_RELOC_ARM_PLT32
2270 ENUMX
2271   BFD_RELOC_ARM_RELATIVE
2272 ENUMX
2273   BFD_RELOC_ARM_GOTOFF
2274 ENUMX
2275   BFD_RELOC_ARM_GOTPC
2276 ENUMDOC
2277   These relocs are only used within the ARM assembler.  They are not
2278   (at present) written to any object files.
2279
2280 ENUM
2281   BFD_RELOC_SH_PCDISP8BY2
2282 ENUMX
2283   BFD_RELOC_SH_PCDISP12BY2
2284 ENUMX
2285   BFD_RELOC_SH_IMM4
2286 ENUMX
2287   BFD_RELOC_SH_IMM4BY2
2288 ENUMX
2289   BFD_RELOC_SH_IMM4BY4
2290 ENUMX
2291   BFD_RELOC_SH_IMM8
2292 ENUMX
2293   BFD_RELOC_SH_IMM8BY2
2294 ENUMX
2295   BFD_RELOC_SH_IMM8BY4
2296 ENUMX
2297   BFD_RELOC_SH_PCRELIMM8BY2
2298 ENUMX
2299   BFD_RELOC_SH_PCRELIMM8BY4
2300 ENUMX
2301   BFD_RELOC_SH_SWITCH16
2302 ENUMX
2303   BFD_RELOC_SH_SWITCH32
2304 ENUMX
2305   BFD_RELOC_SH_USES
2306 ENUMX
2307   BFD_RELOC_SH_COUNT
2308 ENUMX
2309   BFD_RELOC_SH_ALIGN
2310 ENUMX
2311   BFD_RELOC_SH_CODE
2312 ENUMX
2313   BFD_RELOC_SH_DATA
2314 ENUMX
2315   BFD_RELOC_SH_LABEL
2316 ENUMX
2317   BFD_RELOC_SH_LOOP_START
2318 ENUMX
2319   BFD_RELOC_SH_LOOP_END
2320 ENUMX
2321   BFD_RELOC_SH_COPY
2322 ENUMX
2323   BFD_RELOC_SH_GLOB_DAT
2324 ENUMX
2325   BFD_RELOC_SH_JMP_SLOT
2326 ENUMX
2327   BFD_RELOC_SH_RELATIVE
2328 ENUMX
2329   BFD_RELOC_SH_GOTPC
2330 ENUMDOC
2331   Hitachi SH relocs.  Not all of these appear in object files.
2332
2333 ENUM
2334   BFD_RELOC_THUMB_PCREL_BRANCH9
2335 ENUMX
2336   BFD_RELOC_THUMB_PCREL_BRANCH12
2337 ENUMX
2338   BFD_RELOC_THUMB_PCREL_BRANCH23
2339 ENUMDOC
2340   Thumb 23-, 12- and 9-bit pc-relative branches.  The lowest bit must
2341   be zero and is not stored in the instruction.
2342
2343 ENUM
2344   BFD_RELOC_ARC_B22_PCREL
2345 ENUMDOC
2346   ARC Cores relocs.
2347   ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
2348   not stored in the instruction.  The high 20 bits are installed in bits 26
2349   through 7 of the instruction.
2350 ENUM
2351   BFD_RELOC_ARC_B26
2352 ENUMDOC
2353   ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
2354   stored in the instruction.  The high 24 bits are installed in bits 23
2355   through 0.
2356
2357 ENUM
2358   BFD_RELOC_D10V_10_PCREL_R
2359 ENUMDOC
2360   Mitsubishi D10V relocs.
2361   This is a 10-bit reloc with the right 2 bits
2362   assumed to be 0.
2363 ENUM
2364   BFD_RELOC_D10V_10_PCREL_L
2365 ENUMDOC
2366   Mitsubishi D10V relocs.
2367   This is a 10-bit reloc with the right 2 bits
2368   assumed to be 0.  This is the same as the previous reloc
2369   except it is in the left container, i.e.,
2370   shifted left 15 bits.
2371 ENUM
2372   BFD_RELOC_D10V_18
2373 ENUMDOC
2374   This is an 18-bit reloc with the right 2 bits
2375   assumed to be 0.
2376 ENUM
2377   BFD_RELOC_D10V_18_PCREL
2378 ENUMDOC
2379   This is an 18-bit reloc with the right 2 bits
2380   assumed to be 0.
2381
2382 ENUM
2383   BFD_RELOC_D30V_6
2384 ENUMDOC
2385   Mitsubishi D30V relocs.
2386   This is a 6-bit absolute reloc.
2387 ENUM
2388   BFD_RELOC_D30V_9_PCREL
2389 ENUMDOC
2390   This is a 6-bit pc-relative reloc with
2391   the right 3 bits assumed to be 0.
2392 ENUM
2393   BFD_RELOC_D30V_9_PCREL_R
2394 ENUMDOC
2395   This is a 6-bit pc-relative reloc with
2396   the right 3 bits assumed to be 0. Same
2397   as the previous reloc but on the right side
2398   of the container.
2399 ENUM
2400   BFD_RELOC_D30V_15
2401 ENUMDOC
2402   This is a 12-bit absolute reloc with the
2403   right 3 bitsassumed to be 0.
2404 ENUM
2405   BFD_RELOC_D30V_15_PCREL
2406 ENUMDOC
2407   This is a 12-bit pc-relative reloc with
2408   the right 3 bits assumed to be 0.
2409 ENUM
2410   BFD_RELOC_D30V_15_PCREL_R
2411 ENUMDOC
2412   This is a 12-bit pc-relative reloc with
2413   the right 3 bits assumed to be 0. Same
2414   as the previous reloc but on the right side
2415   of the container.
2416 ENUM
2417   BFD_RELOC_D30V_21
2418 ENUMDOC
2419   This is an 18-bit absolute reloc with
2420   the right 3 bits assumed to be 0.
2421 ENUM
2422   BFD_RELOC_D30V_21_PCREL
2423 ENUMDOC
2424   This is an 18-bit pc-relative reloc with
2425   the right 3 bits assumed to be 0.
2426 ENUM
2427   BFD_RELOC_D30V_21_PCREL_R
2428 ENUMDOC
2429   This is an 18-bit pc-relative reloc with
2430   the right 3 bits assumed to be 0. Same
2431   as the previous reloc but on the right side
2432   of the container.
2433 ENUM
2434   BFD_RELOC_D30V_32
2435 ENUMDOC
2436   This is a 32-bit absolute reloc.
2437 ENUM
2438   BFD_RELOC_D30V_32_PCREL
2439 ENUMDOC
2440   This is a 32-bit pc-relative reloc.
2441
2442 ENUM
2443   BFD_RELOC_M32R_24
2444 ENUMDOC
2445   Mitsubishi M32R relocs.
2446   This is a 24 bit absolute address.
2447 ENUM
2448   BFD_RELOC_M32R_10_PCREL
2449 ENUMDOC
2450   This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
2451 ENUM
2452   BFD_RELOC_M32R_18_PCREL
2453 ENUMDOC
2454   This is an 18-bit reloc with the right 2 bits assumed to be 0.
2455 ENUM
2456   BFD_RELOC_M32R_26_PCREL
2457 ENUMDOC
2458   This is a 26-bit reloc with the right 2 bits assumed to be 0.
2459 ENUM
2460   BFD_RELOC_M32R_HI16_ULO
2461 ENUMDOC
2462   This is a 16-bit reloc containing the high 16 bits of an address
2463   used when the lower 16 bits are treated as unsigned.
2464 ENUM
2465   BFD_RELOC_M32R_HI16_SLO
2466 ENUMDOC
2467   This is a 16-bit reloc containing the high 16 bits of an address
2468   used when the lower 16 bits are treated as signed.
2469 ENUM
2470   BFD_RELOC_M32R_LO16
2471 ENUMDOC
2472   This is a 16-bit reloc containing the lower 16 bits of an address.
2473 ENUM
2474   BFD_RELOC_M32R_SDA16
2475 ENUMDOC
2476   This is a 16-bit reloc containing the small data area offset for use in
2477   add3, load, and store instructions.
2478
2479 ENUM
2480   BFD_RELOC_V850_9_PCREL
2481 ENUMDOC
2482   This is a 9-bit reloc
2483 ENUM
2484   BFD_RELOC_V850_22_PCREL
2485 ENUMDOC
2486   This is a 22-bit reloc
2487
2488 ENUM
2489   BFD_RELOC_V850_SDA_16_16_OFFSET
2490 ENUMDOC
2491   This is a 16 bit offset from the short data area pointer.
2492 ENUM
2493   BFD_RELOC_V850_SDA_15_16_OFFSET
2494 ENUMDOC
2495   This is a 16 bit offset (of which only 15 bits are used) from the
2496   short data area pointer.
2497 ENUM
2498   BFD_RELOC_V850_ZDA_16_16_OFFSET
2499 ENUMDOC
2500   This is a 16 bit offset from the zero data area pointer.
2501 ENUM
2502   BFD_RELOC_V850_ZDA_15_16_OFFSET
2503 ENUMDOC
2504   This is a 16 bit offset (of which only 15 bits are used) from the
2505   zero data area pointer.
2506 ENUM
2507   BFD_RELOC_V850_TDA_6_8_OFFSET
2508 ENUMDOC
2509   This is an 8 bit offset (of which only 6 bits are used) from the
2510   tiny data area pointer.
2511 ENUM
2512   BFD_RELOC_V850_TDA_7_8_OFFSET
2513 ENUMDOC
2514   This is an 8bit offset (of which only 7 bits are used) from the tiny
2515   data area pointer.
2516 ENUM
2517   BFD_RELOC_V850_TDA_7_7_OFFSET
2518 ENUMDOC
2519   This is a 7 bit offset from the tiny data area pointer.
2520 ENUM
2521   BFD_RELOC_V850_TDA_16_16_OFFSET
2522 ENUMDOC
2523   This is a 16 bit offset from the tiny data area pointer.
2524 COMMENT
2525 ENUM
2526   BFD_RELOC_V850_TDA_4_5_OFFSET
2527 ENUMDOC
2528   This is a 5 bit offset (of which only 4 bits are used) from the tiny
2529   data area pointer.
2530 ENUM
2531   BFD_RELOC_V850_TDA_4_4_OFFSET
2532 ENUMDOC
2533   This is a 4 bit offset from the tiny data area pointer.
2534 ENUM
2535   BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
2536 ENUMDOC
2537   This is a 16 bit offset from the short data area pointer, with the
2538   bits placed non-contigously in the instruction.
2539 ENUM
2540   BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
2541 ENUMDOC
2542   This is a 16 bit offset from the zero data area pointer, with the
2543   bits placed non-contigously in the instruction.
2544 ENUM
2545   BFD_RELOC_V850_CALLT_6_7_OFFSET
2546 ENUMDOC
2547   This is a 6 bit offset from the call table base pointer.
2548 ENUM
2549   BFD_RELOC_V850_CALLT_16_16_OFFSET
2550 ENUMDOC
2551   This is a 16 bit offset from the call table base pointer.
2552 COMMENT
2553
2554 ENUM
2555   BFD_RELOC_MN10300_32_PCREL
2556 ENUMDOC
2557   This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2558   instruction.
2559 ENUM
2560   BFD_RELOC_MN10300_16_PCREL
2561 ENUMDOC
2562   This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2563   instruction.
2564
2565 ENUM
2566   BFD_RELOC_TIC30_LDP
2567 ENUMDOC
2568   This is a 8bit DP reloc for the tms320c30, where the most
2569   significant 8 bits of a 24 bit word are placed into the least
2570   significant 8 bits of the opcode.
2571
2572 ENUM
2573   BFD_RELOC_TIC54X_PARTLS7
2574 ENUMDOC
2575   This is a 7bit reloc for the tms320c54x, where the least
2576   significant 7 bits of a 16 bit word are placed into the least
2577   significant 7 bits of the opcode.
2578
2579 ENUM
2580   BFD_RELOC_TIC54X_PARTMS9
2581 ENUMDOC
2582   This is a 9bit DP reloc for the tms320c54x, where the most
2583   significant 9 bits of a 16 bit word are placed into the least
2584   significant 9 bits of the opcode.
2585
2586 ENUM
2587   BFD_RELOC_TIC54X_23
2588 ENUMDOC
2589   This is an extended address 23-bit reloc for the tms320c54x.
2590
2591 ENUM
2592   BFD_RELOC_TIC54X_16_OF_23
2593 ENUMDOC
2594   This is a 16-bit reloc for the tms320c54x, where the least
2595   significant 16 bits of a 23-bit extended address are placed into
2596   the opcode.
2597
2598 ENUM
2599   BFD_RELOC_TIC54X_MS7_OF_23
2600 ENUMDOC
2601   This is a reloc for the tms320c54x, where the most
2602   significant 7 bits of a 23-bit extended address are placed into
2603   the opcode.
2604
2605 ENUM
2606   BFD_RELOC_FR30_48
2607 ENUMDOC
2608   This is a 48 bit reloc for the FR30 that stores 32 bits.
2609 ENUM
2610   BFD_RELOC_FR30_20
2611 ENUMDOC
2612   This is a 32 bit reloc for the FR30 that stores 20 bits split up into
2613   two sections.
2614 ENUM
2615   BFD_RELOC_FR30_6_IN_4
2616 ENUMDOC
2617   This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
2618   4 bits.
2619 ENUM
2620   BFD_RELOC_FR30_8_IN_8
2621 ENUMDOC
2622   This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
2623   into 8 bits.
2624 ENUM
2625   BFD_RELOC_FR30_9_IN_8
2626 ENUMDOC
2627   This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
2628   into 8 bits.
2629 ENUM
2630   BFD_RELOC_FR30_10_IN_8
2631 ENUMDOC
2632   This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
2633   into 8 bits.
2634 ENUM
2635   BFD_RELOC_FR30_9_PCREL
2636 ENUMDOC
2637   This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
2638   short offset into 8 bits.
2639 ENUM
2640   BFD_RELOC_FR30_12_PCREL
2641 ENUMDOC
2642   This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
2643   short offset into 11 bits.
2644
2645 ENUM
2646   BFD_RELOC_MCORE_PCREL_IMM8BY4
2647 ENUMX
2648   BFD_RELOC_MCORE_PCREL_IMM11BY2
2649 ENUMX
2650   BFD_RELOC_MCORE_PCREL_IMM4BY2
2651 ENUMX
2652   BFD_RELOC_MCORE_PCREL_32
2653 ENUMX
2654   BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
2655 ENUMX
2656   BFD_RELOC_MCORE_RVA
2657 ENUMDOC
2658   Motorola Mcore relocations.
2659
2660 ENUM
2661   BFD_RELOC_AVR_7_PCREL
2662 ENUMDOC
2663   This is a 16 bit reloc for the AVR that stores 8 bit pc relative
2664   short offset into 7 bits.
2665 ENUM
2666   BFD_RELOC_AVR_13_PCREL
2667 ENUMDOC
2668   This is a 16 bit reloc for the AVR that stores 13 bit pc relative
2669   short offset into 12 bits.
2670 ENUM
2671   BFD_RELOC_AVR_16_PM
2672 ENUMDOC
2673   This is a 16 bit reloc for the AVR that stores 17 bit value (usually
2674   program memory address) into 16 bits.
2675 ENUM
2676   BFD_RELOC_AVR_LO8_LDI
2677 ENUMDOC
2678   This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2679   data memory address) into 8 bit immediate value of LDI insn.
2680 ENUM
2681   BFD_RELOC_AVR_HI8_LDI
2682 ENUMDOC
2683   This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2684   of data memory address) into 8 bit immediate value of LDI insn.
2685 ENUM
2686   BFD_RELOC_AVR_HH8_LDI
2687 ENUMDOC
2688   This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2689   of program memory address) into 8 bit immediate value of LDI insn.
2690 ENUM
2691   BFD_RELOC_AVR_LO8_LDI_NEG
2692 ENUMDOC
2693   This is a 16 bit reloc for the AVR that stores negated 8 bit value
2694   (usually data memory address) into 8 bit immediate value of SUBI insn.
2695 ENUM
2696   BFD_RELOC_AVR_HI8_LDI_NEG
2697 ENUMDOC
2698   This is a 16 bit reloc for the AVR that stores negated 8 bit value
2699   (high 8 bit of data memory address) into 8 bit immediate value of
2700   SUBI insn.
2701 ENUM
2702   BFD_RELOC_AVR_HH8_LDI_NEG
2703 ENUMDOC
2704   This is a 16 bit reloc for the AVR that stores negated 8 bit value
2705   (most high 8 bit of program memory address) into 8 bit immediate value
2706   of LDI or SUBI insn.
2707 ENUM
2708   BFD_RELOC_AVR_LO8_LDI_PM
2709 ENUMDOC
2710   This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2711   command address) into 8 bit immediate value of LDI insn.
2712 ENUM
2713   BFD_RELOC_AVR_HI8_LDI_PM
2714 ENUMDOC
2715   This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2716   of command address) into 8 bit immediate value of LDI insn.
2717 ENUM
2718   BFD_RELOC_AVR_HH8_LDI_PM
2719 ENUMDOC
2720   This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2721   of command address) into 8 bit immediate value of LDI insn.
2722 ENUM
2723   BFD_RELOC_AVR_LO8_LDI_PM_NEG
2724 ENUMDOC
2725   This is a 16 bit reloc for the AVR that stores negated 8 bit value
2726   (usually command address) into 8 bit immediate value of SUBI insn.
2727 ENUM
2728   BFD_RELOC_AVR_HI8_LDI_PM_NEG
2729 ENUMDOC
2730   This is a 16 bit reloc for the AVR that stores negated 8 bit value
2731   (high 8 bit of 16 bit command address) into 8 bit immediate value
2732   of SUBI insn.
2733 ENUM
2734   BFD_RELOC_AVR_HH8_LDI_PM_NEG
2735 ENUMDOC
2736   This is a 16 bit reloc for the AVR that stores negated 8 bit value
2737   (high 6 bit of 22 bit command address) into 8 bit immediate
2738   value of SUBI insn.
2739 ENUM
2740   BFD_RELOC_AVR_CALL
2741 ENUMDOC
2742   This is a 32 bit reloc for the AVR that stores 23 bit value
2743   into 22 bits.
2744
2745 ENUM
2746   BFD_RELOC_390_12
2747 ENUMDOC
2748    Direct 12 bit.
2749 ENUM
2750   BFD_RELOC_390_GOT12
2751 ENUMDOC
2752   12 bit GOT offset.
2753 ENUM
2754   BFD_RELOC_390_PLT32
2755 ENUMDOC
2756   32 bit PC relative PLT address.
2757 ENUM
2758   BFD_RELOC_390_COPY
2759 ENUMDOC
2760   Copy symbol at runtime.
2761 ENUM
2762   BFD_RELOC_390_GLOB_DAT
2763 ENUMDOC
2764   Create GOT entry.
2765 ENUM
2766   BFD_RELOC_390_JMP_SLOT
2767 ENUMDOC
2768   Create PLT entry.
2769 ENUM
2770   BFD_RELOC_390_RELATIVE
2771 ENUMDOC
2772   Adjust by program base.
2773 ENUM
2774   BFD_RELOC_390_GOTPC
2775 ENUMDOC
2776   32 bit PC relative offset to GOT.
2777 ENUM
2778   BFD_RELOC_390_GOT16
2779 ENUMDOC
2780   16 bit GOT offset.
2781 ENUM
2782   BFD_RELOC_390_PC16DBL
2783 ENUMDOC
2784   PC relative 16 bit shifted by 1.
2785 ENUM
2786   BFD_RELOC_390_PLT16DBL
2787 ENUMDOC
2788   16 bit PC rel. PLT shifted by 1.
2789 ENUM
2790   BFD_RELOC_390_PC32DBL
2791 ENUMDOC
2792   PC relative 32 bit shifted by 1.
2793 ENUM
2794   BFD_RELOC_390_PLT32DBL
2795 ENUMDOC
2796   32 bit PC rel. PLT shifted by 1.
2797 ENUM
2798   BFD_RELOC_390_GOTPCDBL
2799 ENUMDOC
2800   32 bit PC rel. GOT shifted by 1.
2801 ENUM
2802   BFD_RELOC_390_GOT64
2803 ENUMDOC
2804   64 bit GOT offset.
2805 ENUM
2806   BFD_RELOC_390_PLT64
2807 ENUMDOC
2808   64 bit PC relative PLT address.
2809 ENUM
2810   BFD_RELOC_390_GOTENT
2811 ENUMDOC
2812   32 bit rel. offset to GOT entry.
2813
2814 ENUM
2815   BFD_RELOC_VTABLE_INHERIT
2816 ENUMX
2817   BFD_RELOC_VTABLE_ENTRY
2818 ENUMDOC
2819   These two relocations are used by the linker to determine which of
2820   the entries in a C++ virtual function table are actually used.  When
2821   the --gc-sections option is given, the linker will zero out the entries
2822   that are not used, so that the code for those functions need not be
2823   included in the output.
2824
2825   VTABLE_INHERIT is a zero-space relocation used to describe to the
2826   linker the inheritence tree of a C++ virtual function table.  The
2827   relocation's symbol should be the parent class' vtable, and the
2828   relocation should be located at the child vtable.
2829
2830   VTABLE_ENTRY is a zero-space relocation that describes the use of a
2831   virtual function table entry.  The reloc's symbol should refer to the
2832   table of the class mentioned in the code.  Off of that base, an offset
2833   describes the entry that is being used.  For Rela hosts, this offset
2834   is stored in the reloc's addend.  For Rel hosts, we are forced to put
2835   this offset in the reloc's section offset.
2836
2837 ENUM
2838   BFD_RELOC_IA64_IMM14
2839 ENUMX
2840   BFD_RELOC_IA64_IMM22
2841 ENUMX
2842   BFD_RELOC_IA64_IMM64
2843 ENUMX
2844   BFD_RELOC_IA64_DIR32MSB
2845 ENUMX
2846   BFD_RELOC_IA64_DIR32LSB
2847 ENUMX
2848   BFD_RELOC_IA64_DIR64MSB
2849 ENUMX
2850   BFD_RELOC_IA64_DIR64LSB
2851 ENUMX
2852   BFD_RELOC_IA64_GPREL22
2853 ENUMX
2854   BFD_RELOC_IA64_GPREL64I
2855 ENUMX
2856   BFD_RELOC_IA64_GPREL32MSB
2857 ENUMX
2858   BFD_RELOC_IA64_GPREL32LSB
2859 ENUMX
2860   BFD_RELOC_IA64_GPREL64MSB
2861 ENUMX
2862   BFD_RELOC_IA64_GPREL64LSB
2863 ENUMX
2864   BFD_RELOC_IA64_LTOFF22
2865 ENUMX
2866   BFD_RELOC_IA64_LTOFF64I
2867 ENUMX
2868   BFD_RELOC_IA64_PLTOFF22
2869 ENUMX
2870   BFD_RELOC_IA64_PLTOFF64I
2871 ENUMX
2872   BFD_RELOC_IA64_PLTOFF64MSB
2873 ENUMX
2874   BFD_RELOC_IA64_PLTOFF64LSB
2875 ENUMX
2876   BFD_RELOC_IA64_FPTR64I
2877 ENUMX
2878   BFD_RELOC_IA64_FPTR32MSB
2879 ENUMX
2880   BFD_RELOC_IA64_FPTR32LSB
2881 ENUMX
2882   BFD_RELOC_IA64_FPTR64MSB
2883 ENUMX
2884   BFD_RELOC_IA64_FPTR64LSB
2885 ENUMX
2886   BFD_RELOC_IA64_PCREL21B
2887 ENUMX
2888   BFD_RELOC_IA64_PCREL21BI
2889 ENUMX
2890   BFD_RELOC_IA64_PCREL21M
2891 ENUMX
2892   BFD_RELOC_IA64_PCREL21F
2893 ENUMX
2894   BFD_RELOC_IA64_PCREL22
2895 ENUMX
2896   BFD_RELOC_IA64_PCREL60B
2897 ENUMX
2898   BFD_RELOC_IA64_PCREL64I
2899 ENUMX
2900   BFD_RELOC_IA64_PCREL32MSB
2901 ENUMX
2902   BFD_RELOC_IA64_PCREL32LSB
2903 ENUMX
2904   BFD_RELOC_IA64_PCREL64MSB
2905 ENUMX
2906   BFD_RELOC_IA64_PCREL64LSB
2907 ENUMX
2908   BFD_RELOC_IA64_LTOFF_FPTR22
2909 ENUMX
2910   BFD_RELOC_IA64_LTOFF_FPTR64I
2911 ENUMX
2912   BFD_RELOC_IA64_LTOFF_FPTR64MSB
2913 ENUMX
2914   BFD_RELOC_IA64_LTOFF_FPTR64LSB
2915 ENUMX
2916   BFD_RELOC_IA64_SEGREL32MSB
2917 ENUMX
2918   BFD_RELOC_IA64_SEGREL32LSB
2919 ENUMX
2920   BFD_RELOC_IA64_SEGREL64MSB
2921 ENUMX
2922   BFD_RELOC_IA64_SEGREL64LSB
2923 ENUMX
2924   BFD_RELOC_IA64_SECREL32MSB
2925 ENUMX
2926   BFD_RELOC_IA64_SECREL32LSB
2927 ENUMX
2928   BFD_RELOC_IA64_SECREL64MSB
2929 ENUMX
2930   BFD_RELOC_IA64_SECREL64LSB
2931 ENUMX
2932   BFD_RELOC_IA64_REL32MSB
2933 ENUMX
2934   BFD_RELOC_IA64_REL32LSB
2935 ENUMX
2936   BFD_RELOC_IA64_REL64MSB
2937 ENUMX
2938   BFD_RELOC_IA64_REL64LSB
2939 ENUMX
2940   BFD_RELOC_IA64_LTV32MSB
2941 ENUMX
2942   BFD_RELOC_IA64_LTV32LSB
2943 ENUMX
2944   BFD_RELOC_IA64_LTV64MSB
2945 ENUMX
2946   BFD_RELOC_IA64_LTV64LSB
2947 ENUMX
2948   BFD_RELOC_IA64_IPLTMSB
2949 ENUMX
2950   BFD_RELOC_IA64_IPLTLSB
2951 ENUMX
2952   BFD_RELOC_IA64_COPY
2953 ENUMX
2954   BFD_RELOC_IA64_TPREL22
2955 ENUMX
2956   BFD_RELOC_IA64_TPREL64MSB
2957 ENUMX
2958   BFD_RELOC_IA64_TPREL64LSB
2959 ENUMX
2960   BFD_RELOC_IA64_LTOFF_TP22
2961 ENUMX
2962   BFD_RELOC_IA64_LTOFF22X
2963 ENUMX
2964   BFD_RELOC_IA64_LDXMOV
2965 ENUMDOC
2966   Intel IA64 Relocations.
2967
2968 ENUM
2969   BFD_RELOC_M68HC11_HI8
2970 ENUMDOC
2971   Motorola 68HC11 reloc.
2972   This is the 8 bits high part of an absolute address.
2973 ENUM
2974   BFD_RELOC_M68HC11_LO8
2975 ENUMDOC
2976   Motorola 68HC11 reloc.
2977   This is the 8 bits low part of an absolute address.
2978 ENUM
2979   BFD_RELOC_M68HC11_3B
2980 ENUMDOC
2981   Motorola 68HC11 reloc.
2982   This is the 3 bits of a value.
2983
2984 ENUM
2985   BFD_RELOC_CRIS_BDISP8
2986 ENUMX
2987   BFD_RELOC_CRIS_UNSIGNED_5
2988 ENUMX
2989   BFD_RELOC_CRIS_SIGNED_6
2990 ENUMX
2991   BFD_RELOC_CRIS_UNSIGNED_6
2992 ENUMX
2993   BFD_RELOC_CRIS_UNSIGNED_4
2994 ENUMDOC
2995   These relocs are only used within the CRIS assembler.  They are not
2996   (at present) written to any object files.
2997
2998 ENUM
2999   BFD_RELOC_860_COPY
3000 ENUMX
3001   BFD_RELOC_860_GLOB_DAT
3002 ENUMX
3003   BFD_RELOC_860_JUMP_SLOT
3004 ENUMX
3005   BFD_RELOC_860_RELATIVE
3006 ENUMX
3007   BFD_RELOC_860_PC26
3008 ENUMX
3009   BFD_RELOC_860_PLT26
3010 ENUMX
3011   BFD_RELOC_860_PC16
3012 ENUMX
3013   BFD_RELOC_860_LOW0
3014 ENUMX
3015   BFD_RELOC_860_SPLIT0
3016 ENUMX
3017   BFD_RELOC_860_LOW1
3018 ENUMX
3019   BFD_RELOC_860_SPLIT1
3020 ENUMX
3021   BFD_RELOC_860_LOW2
3022 ENUMX
3023   BFD_RELOC_860_SPLIT2
3024 ENUMX
3025   BFD_RELOC_860_LOW3
3026 ENUMX
3027   BFD_RELOC_860_LOGOT0
3028 ENUMX
3029   BFD_RELOC_860_SPGOT0
3030 ENUMX
3031   BFD_RELOC_860_LOGOT1
3032 ENUMX
3033   BFD_RELOC_860_SPGOT1
3034 ENUMX
3035   BFD_RELOC_860_LOGOTOFF0
3036 ENUMX
3037   BFD_RELOC_860_SPGOTOFF0
3038 ENUMX
3039   BFD_RELOC_860_LOGOTOFF1
3040 ENUMX
3041   BFD_RELOC_860_SPGOTOFF1
3042 ENUMX
3043   BFD_RELOC_860_LOGOTOFF2
3044 ENUMX
3045   BFD_RELOC_860_LOGOTOFF3
3046 ENUMX
3047   BFD_RELOC_860_LOPC
3048 ENUMX
3049   BFD_RELOC_860_HIGHADJ
3050 ENUMX
3051   BFD_RELOC_860_HAGOT
3052 ENUMX
3053   BFD_RELOC_860_HAGOTOFF
3054 ENUMX
3055   BFD_RELOC_860_HAPC
3056 ENUMX
3057   BFD_RELOC_860_HIGH
3058 ENUMX
3059   BFD_RELOC_860_HIGOT
3060 ENUMX
3061   BFD_RELOC_860_HIGOTOFF
3062 ENUMDOC
3063   Intel i860 Relocations.
3064
3065 ENDSENUM
3066   BFD_RELOC_UNUSED
3067 CODE_FRAGMENT
3068 .
3069 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
3070 */
3071
3072 /*
3073 FUNCTION
3074         bfd_reloc_type_lookup
3075
3076 SYNOPSIS
3077         reloc_howto_type *
3078         bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code);
3079
3080 DESCRIPTION
3081         Return a pointer to a howto structure which, when
3082         invoked, will perform the relocation @var{code} on data from the
3083         architecture noted.
3084
3085 */
3086
3087 reloc_howto_type *
3088 bfd_reloc_type_lookup (abfd, code)
3089      bfd *abfd;
3090      bfd_reloc_code_real_type code;
3091 {
3092   return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
3093 }
3094
3095 static reloc_howto_type bfd_howto_32 =
3096 HOWTO (0, 00, 2, 32, false, 0, complain_overflow_bitfield, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
3097
3098 /*
3099 INTERNAL_FUNCTION
3100         bfd_default_reloc_type_lookup
3101
3102 SYNOPSIS
3103         reloc_howto_type *bfd_default_reloc_type_lookup
3104         (bfd *abfd, bfd_reloc_code_real_type  code);
3105
3106 DESCRIPTION
3107         Provides a default relocation lookup routine for any architecture.
3108
3109 */
3110
3111 reloc_howto_type *
3112 bfd_default_reloc_type_lookup (abfd, code)
3113      bfd *abfd;
3114      bfd_reloc_code_real_type code;
3115 {
3116   switch (code)
3117     {
3118     case BFD_RELOC_CTOR:
3119       /* The type of reloc used in a ctor, which will be as wide as the
3120          address - so either a 64, 32, or 16 bitter.  */
3121       switch (bfd_get_arch_info (abfd)->bits_per_address)
3122         {
3123         case 64:
3124           BFD_FAIL ();
3125         case 32:
3126           return &bfd_howto_32;
3127         case 16:
3128           BFD_FAIL ();
3129         default:
3130           BFD_FAIL ();
3131         }
3132     default:
3133       BFD_FAIL ();
3134     }
3135   return (reloc_howto_type *) NULL;
3136 }
3137
3138 /*
3139 FUNCTION
3140         bfd_get_reloc_code_name
3141
3142 SYNOPSIS
3143         const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
3144
3145 DESCRIPTION
3146         Provides a printable name for the supplied relocation code.
3147         Useful mainly for printing error messages.
3148 */
3149
3150 const char *
3151 bfd_get_reloc_code_name (code)
3152      bfd_reloc_code_real_type code;
3153 {
3154   if (code > BFD_RELOC_UNUSED)
3155     return 0;
3156   return bfd_reloc_code_real_names[(int)code];
3157 }
3158
3159 /*
3160 INTERNAL_FUNCTION
3161         bfd_generic_relax_section
3162
3163 SYNOPSIS
3164         boolean bfd_generic_relax_section
3165          (bfd *abfd,
3166           asection *section,
3167           struct bfd_link_info *,
3168           boolean *);
3169
3170 DESCRIPTION
3171         Provides default handling for relaxing for back ends which
3172         don't do relaxing -- i.e., does nothing.
3173 */
3174
3175 /*ARGSUSED*/
3176 boolean
3177 bfd_generic_relax_section (abfd, section, link_info, again)
3178      bfd *abfd ATTRIBUTE_UNUSED;
3179      asection *section ATTRIBUTE_UNUSED;
3180      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3181      boolean *again;
3182 {
3183   *again = false;
3184   return true;
3185 }
3186
3187 /*
3188 INTERNAL_FUNCTION
3189         bfd_generic_gc_sections
3190
3191 SYNOPSIS
3192         boolean bfd_generic_gc_sections
3193          (bfd *, struct bfd_link_info *);
3194
3195 DESCRIPTION
3196         Provides default handling for relaxing for back ends which
3197         don't do section gc -- i.e., does nothing.
3198 */
3199
3200 /*ARGSUSED*/
3201 boolean
3202 bfd_generic_gc_sections (abfd, link_info)
3203      bfd *abfd ATTRIBUTE_UNUSED;
3204      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3205 {
3206   return true;
3207 }
3208
3209 /*
3210 INTERNAL_FUNCTION
3211         bfd_generic_get_relocated_section_contents
3212
3213 SYNOPSIS
3214         bfd_byte *
3215            bfd_generic_get_relocated_section_contents (bfd *abfd,
3216              struct bfd_link_info *link_info,
3217              struct bfd_link_order *link_order,
3218              bfd_byte *data,
3219              boolean relocateable,
3220              asymbol **symbols);
3221
3222 DESCRIPTION
3223         Provides default handling of relocation effort for back ends
3224         which can't be bothered to do it efficiently.
3225
3226 */
3227
3228 bfd_byte *
3229 bfd_generic_get_relocated_section_contents (abfd, link_info, link_order, data,
3230                                             relocateable, symbols)
3231      bfd *abfd;
3232      struct bfd_link_info *link_info;
3233      struct bfd_link_order *link_order;
3234      bfd_byte *data;
3235      boolean relocateable;
3236      asymbol **symbols;
3237 {
3238   /* Get enough memory to hold the stuff */
3239   bfd *input_bfd = link_order->u.indirect.section->owner;
3240   asection *input_section = link_order->u.indirect.section;
3241
3242   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
3243   arelent **reloc_vector = NULL;
3244   long reloc_count;
3245
3246   if (reloc_size < 0)
3247     goto error_return;
3248
3249   reloc_vector = (arelent **) bfd_malloc ((size_t) reloc_size);
3250   if (reloc_vector == NULL && reloc_size != 0)
3251     goto error_return;
3252
3253   /* read in the section */
3254   if (!bfd_get_section_contents (input_bfd,
3255                                  input_section,
3256                                  (PTR) data,
3257                                  0,
3258                                  input_section->_raw_size))
3259     goto error_return;
3260
3261   /* We're not relaxing the section, so just copy the size info */
3262   input_section->_cooked_size = input_section->_raw_size;
3263   input_section->reloc_done = true;
3264
3265   reloc_count = bfd_canonicalize_reloc (input_bfd,
3266                                         input_section,
3267                                         reloc_vector,
3268                                         symbols);
3269   if (reloc_count < 0)
3270     goto error_return;
3271
3272   if (reloc_count > 0)
3273     {
3274       arelent **parent;
3275       for (parent = reloc_vector; *parent != (arelent *) NULL;
3276            parent++)
3277         {
3278           char *error_message = (char *) NULL;
3279           bfd_reloc_status_type r =
3280             bfd_perform_relocation (input_bfd,
3281                                     *parent,
3282                                     (PTR) data,
3283                                     input_section,
3284                                     relocateable ? abfd : (bfd *) NULL,
3285                                     &error_message);
3286
3287           if (relocateable)
3288             {
3289               asection *os = input_section->output_section;
3290
3291               /* A partial link, so keep the relocs */
3292               os->orelocation[os->reloc_count] = *parent;
3293               os->reloc_count++;
3294             }
3295
3296           if (r != bfd_reloc_ok)
3297             {
3298               switch (r)
3299                 {
3300                 case bfd_reloc_undefined:
3301                   if (!((*link_info->callbacks->undefined_symbol)
3302                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
3303                          input_bfd, input_section, (*parent)->address,
3304                          true)))
3305                     goto error_return;
3306                   break;
3307                 case bfd_reloc_dangerous:
3308                   BFD_ASSERT (error_message != (char *) NULL);
3309                   if (!((*link_info->callbacks->reloc_dangerous)
3310                         (link_info, error_message, input_bfd, input_section,
3311                          (*parent)->address)))
3312                     goto error_return;
3313                   break;
3314                 case bfd_reloc_overflow:
3315                   if (!((*link_info->callbacks->reloc_overflow)
3316                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
3317                          (*parent)->howto->name, (*parent)->addend,
3318                          input_bfd, input_section, (*parent)->address)))
3319                     goto error_return;
3320                   break;
3321                 case bfd_reloc_outofrange:
3322                 default:
3323                   abort ();
3324                   break;
3325                 }
3326
3327             }
3328         }
3329     }
3330   if (reloc_vector != NULL)
3331     free (reloc_vector);
3332   return data;
3333
3334 error_return:
3335   if (reloc_vector != NULL)
3336     free (reloc_vector);
3337   return NULL;
3338 }