bfd/reloc.c

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