bfd/reloc.c

   1 /* BFD support for handling relocation entries.
   2    Copyright (C) 1990-2020 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 /*
  23 SECTION
  24         Relocations
  25
  26         BFD maintains relocations in much the same way it maintains
  27         symbols: they are left alone until required, then read in
  28         en-masse and translated into an internal form.  A common
  29         routine <<bfd_perform_relocation>> acts upon the
  30         canonical form to do the fixup.
  31
  32         Relocations are maintained on a per section basis,
  33         while symbols are maintained on a per BFD basis.
  34
  35         All that a back end has to do to fit the BFD interface is to create
  36         a <<struct reloc_cache_entry>> for each relocation
  37         in a particular section, and fill in the right bits of the structures.
  38
  39 @menu
  40 @* typedef arelent::
  41 @* howto manager::
  42 @end menu
  43
  44 */
  45
  46 /* DO compile in the reloc_code name table from libbfd.h.  */
  47 #define _BFD_MAKE_TABLE_bfd_reloc_code_real
  48
  49 #include "sysdep.h"
  50 #include "bfd.h"
  51 #include "bfdlink.h"
  52 #include "libbfd.h"
  53 #include "bfdver.h"
  54 #include "coff/internal.h"
  55 /*
  56 DOCDD
  57 INODE
  58         typedef arelent, howto manager, Relocations, Relocations
  59
  60 SUBSECTION
  61         typedef arelent
  62
  63         This is the structure of a relocation entry:
  64
  65 CODE_FRAGMENT
  66 .
  67 .typedef enum bfd_reloc_status
  68 .{
  69 .  {* No errors detected.  Note - the value 2 is used so that it
  70 .     will not be mistaken for the boolean TRUE or FALSE values.  *}
  71 .  bfd_reloc_ok = 2,
  72 .
  73 .  {* The relocation was performed, but there was an overflow.  *}
  74 .  bfd_reloc_overflow,
  75 .
  76 .  {* The address to relocate was not within the section supplied.  *}
  77 .  bfd_reloc_outofrange,
  78 .
  79 .  {* Used by special functions.  *}
  80 .  bfd_reloc_continue,
  81 .
  82 .  {* Unsupported relocation size requested.  *}
  83 .  bfd_reloc_notsupported,
  84 .
  85 .  {* Unused.  *}
  86 .  bfd_reloc_other,
  87 .
  88 .  {* The symbol to relocate against was undefined.  *}
  89 .  bfd_reloc_undefined,
  90 .
  91 .  {* The relocation was performed, but may not be ok.  If this type is
  92 .     returned, the error_message argument to bfd_perform_relocation
  93 .     will be set.  *}
  94 .  bfd_reloc_dangerous
  95 . }
  96 . bfd_reloc_status_type;
  97 .
  98 .typedef const struct reloc_howto_struct reloc_howto_type;
  99 .
 100 .typedef struct reloc_cache_entry
 101 .{
 102 .  {* A pointer into the canonical table of pointers.  *}
 103 .  struct bfd_symbol **sym_ptr_ptr;
 104 .
 105 .  {* offset in section.  *}
 106 .  bfd_size_type address;
 107 .
 108 .  {* addend for relocation value.  *}
 109 .  bfd_vma addend;
 110 .
 111 .  {* Pointer to how to perform the required relocation.  *}
 112 .  reloc_howto_type *howto;
 113 .
 114 .}
 115 .arelent;
 116 .
 117 */
 118
 119 /*
 120 DESCRIPTION
 121
 122         Here is a description of each of the fields within an <<arelent>>:
 123
 124         o <<sym_ptr_ptr>>
 125
 126         The symbol table pointer points to a pointer to the symbol
 127         associated with the relocation request.  It is the pointer
 128         into the table returned by the back end's
 129         <<canonicalize_symtab>> action. @xref{Symbols}. The symbol is
 130         referenced through a pointer to a pointer so that tools like
 131         the linker can fix up all the symbols of the same name by
 132         modifying only one pointer. The relocation routine looks in
 133         the symbol and uses the base of the section the symbol is
 134         attached to and the value of the symbol as the initial
 135         relocation offset. If the symbol pointer is zero, then the
 136         section provided is looked up.
 137
 138         o <<address>>
 139
 140         The <<address>> field gives the offset in bytes from the base of
 141         the section data which owns the relocation record to the first
 142         byte of relocatable information. The actual data relocated
 143         will be relative to this point; for example, a relocation
 144         type which modifies the bottom two bytes of a four byte word
 145         would not touch the first byte pointed to in a big endian
 146         world.
 147
 148         o <<addend>>
 149
 150         The <<addend>> is a value provided by the back end to be added (!)
 151         to the relocation offset. Its interpretation is dependent upon
 152         the howto. For example, on the 68k the code:
 153
 154 |        char foo[];
 155 |        main()
 156 |                {
 157 |                return foo[0x12345678];
 158 |                }
 159
 160         Could be compiled into:
 161
 162 |        linkw fp,#-4
 163 |        moveb @@#12345678,d0
 164 |        extbl d0
 165 |        unlk fp
 166 |        rts
 167
 168         This could create a reloc pointing to <<foo>>, but leave the
 169         offset in the data, something like:
 170
 171 |RELOCATION RECORDS FOR [.text]:
 172 |offset   type      value
 173 |00000006 32        _foo
 174 |
 175 |00000000 4e56 fffc          ; linkw fp,#-4
 176 |00000004 1039 1234 5678     ; moveb @@#12345678,d0
 177 |0000000a 49c0               ; extbl d0
 178 |0000000c 4e5e               ; unlk fp
 179 |0000000e 4e75               ; rts
 180
 181         Using coff and an 88k, some instructions don't have enough
 182         space in them to represent the full address range, and
 183         pointers have to be loaded in two parts. So you'd get something like:
 184
 185 |        or.u     r13,r0,hi16(_foo+0x12345678)
 186 |        ld.b     r2,r13,lo16(_foo+0x12345678)
 187 |        jmp      r1
 188
 189         This should create two relocs, both pointing to <<_foo>>, and with
 190         0x12340000 in their addend field. The data would consist of:
 191
 192 |RELOCATION RECORDS FOR [.text]:
 193 |offset   type      value
 194 |00000002 HVRT16    _foo+0x12340000
 195 |00000006 LVRT16    _foo+0x12340000
 196 |
 197 |00000000 5da05678           ; or.u r13,r0,0x5678
 198 |00000004 1c4d5678           ; ld.b r2,r13,0x5678
 199 |00000008 f400c001           ; jmp r1
 200
 201         The relocation routine digs out the value from the data, adds
 202         it to the addend to get the original offset, and then adds the
 203         value of <<_foo>>. Note that all 32 bits have to be kept around
 204         somewhere, to cope with carry from bit 15 to bit 16.
 205
 206         One further example is the sparc and the a.out format. The
 207         sparc has a similar problem to the 88k, in that some
 208         instructions don't have room for an entire offset, but on the
 209         sparc the parts are created in odd sized lumps. The designers of
 210         the a.out format chose to not use the data within the section
 211         for storing part of the offset; all the offset is kept within
 212         the reloc. Anything in the data should be ignored.
 213
 214 |        save %sp,-112,%sp
 215 |        sethi %hi(_foo+0x12345678),%g2
 216 |        ldsb [%g2+%lo(_foo+0x12345678)],%i0
 217 |        ret
 218 |        restore
 219
 220         Both relocs contain a pointer to <<foo>>, and the offsets
 221         contain junk.
 222
 223 |RELOCATION RECORDS FOR [.text]:
 224 |offset   type      value
 225 |00000004 HI22      _foo+0x12345678
 226 |00000008 LO10      _foo+0x12345678
 227 |
 228 |00000000 9de3bf90     ; save %sp,-112,%sp
 229 |00000004 05000000     ; sethi %hi(_foo+0),%g2
 230 |00000008 f048a000     ; ldsb [%g2+%lo(_foo+0)],%i0
 231 |0000000c 81c7e008     ; ret
 232 |00000010 81e80000     ; restore
 233
 234         o <<howto>>
 235
 236         The <<howto>> field can be imagined as a
 237         relocation instruction. It is a pointer to a structure which
 238         contains information on what to do with all of the other
 239         information in the reloc record and data section. A back end
 240         would normally have a relocation instruction set and turn
 241         relocations into pointers to the correct structure on input -
 242         but it would be possible to create each howto field on demand.
 243
 244 */
 245
 246 /*
 247 SUBSUBSECTION
 248         <<enum complain_overflow>>
 249
 250         Indicates what sort of overflow checking should be done when
 251         performing a relocation.
 252
 253 CODE_FRAGMENT
 254 .
 255 .enum complain_overflow
 256 .{
 257 .  {* Do not complain on overflow.  *}
 258 .  complain_overflow_dont,
 259 .
 260 .  {* Complain if the value overflows when considered as a signed
 261 .     number one bit larger than the field.  ie. A bitfield of N bits
 262 .     is allowed to represent -2**n to 2**n-1.  *}
 263 .  complain_overflow_bitfield,
 264 .
 265 .  {* Complain if the value overflows when considered as a signed
 266 .     number.  *}
 267 .  complain_overflow_signed,
 268 .
 269 .  {* Complain if the value overflows when considered as an
 270 .     unsigned number.  *}
 271 .  complain_overflow_unsigned
 272 .};
 273
 274 */
 275
 276 /*
 277 SUBSUBSECTION
 278         <<reloc_howto_type>>
 279
 280         The <<reloc_howto_type>> is a structure which contains all the
 281         information that libbfd needs to know to tie up a back end's data.
 282
 283 CODE_FRAGMENT
 284 .struct reloc_howto_struct
 285 .{
 286 .  {* The type field has mainly a documentary use - the back end can
 287 .     do what it wants with it, though normally the back end's idea of
 288 .     an external reloc number is stored in this field.  *}
 289 .  unsigned int type;
 290 .
 291 .  {* The encoded size of the item to be relocated.  This is *not* a
 292 .     power-of-two measure.  Use bfd_get_reloc_size to find the size
 293 .     of the item in bytes.  *}
 294 .  unsigned int size:3;
 295 .
 296 .  {* The number of bits in the field to be relocated.  This is used
 297 .     when doing overflow checking.  *}
 298 .  unsigned int bitsize:7;
 299 .
 300 .  {* The value the final relocation is shifted right by.  This drops
 301 .     unwanted data from the relocation.  *}
 302 .  unsigned int rightshift:6;
 303 .
 304 .  {* The bit position of the reloc value in the destination.
 305 .     The relocated value is left shifted by this amount.  *}
 306 .  unsigned int bitpos:6;
 307 .
 308 .  {* What type of overflow error should be checked for when
 309 .     relocating.  *}
 310 .  ENUM_BITFIELD (complain_overflow) complain_on_overflow:2;
 311 .
 312 .  {* The relocation value should be negated before applying.  *}
 313 .  unsigned int negate:1;
 314 .
 315 .  {* The relocation is relative to the item being relocated.  *}
 316 .  unsigned int pc_relative:1;
 317 .
 318 .  {* Some formats record a relocation addend in the section contents
 319 .     rather than with the relocation.  For ELF formats this is the
 320 .     distinction between USE_REL and USE_RELA (though the code checks
 321 .     for USE_REL == 1/0).  The value of this field is TRUE if the
 322 .     addend is recorded with the section contents; when performing a
 323 .     partial link (ld -r) the section contents (the data) will be
 324 .     modified.  The value of this field is FALSE if addends are
 325 .     recorded with the relocation (in arelent.addend); when performing
 326 .     a partial link the relocation will be modified.
 327 .     All relocations for all ELF USE_RELA targets should set this field
 328 .     to FALSE (values of TRUE should be looked on with suspicion).
 329 .     However, the converse is not true: not all relocations of all ELF
 330 .     USE_REL targets set this field to TRUE.  Why this is so is peculiar
 331 .     to each particular target.  For relocs that aren't used in partial
 332 .     links (e.g. GOT stuff) it doesn't matter what this is set to.  *}
 333 .  unsigned int partial_inplace:1;
 334 .
 335 .  {* When some formats create PC relative instructions, they leave
 336 .     the value of the pc of the place being relocated in the offset
 337 .     slot of the instruction, so that a PC relative relocation can
 338 .     be made just by adding in an ordinary offset (e.g., sun3 a.out).
 339 .     Some formats leave the displacement part of an instruction
 340 .     empty (e.g., ELF); this flag signals the fact.  *}
 341 .  unsigned int pcrel_offset:1;
 342 .
 343 .  {* src_mask selects the part of the instruction (or data) to be used
 344 .     in the relocation sum.  If the target relocations don't have an
 345 .     addend in the reloc, eg. ELF USE_REL, src_mask will normally equal
 346 .     dst_mask to extract the addend from the section contents.  If
 347 .     relocations do have an addend in the reloc, eg. ELF USE_RELA, this
 348 .     field should normally be zero.  Non-zero values for ELF USE_RELA
 349 .     targets should be viewed with suspicion as normally the value in
 350 .     the dst_mask part of the section contents should be ignored.  *}
 351 .  bfd_vma src_mask;
 352 .
 353 .  {* dst_mask selects which parts of the instruction (or data) are
 354 .     replaced with a relocated value.  *}
 355 .  bfd_vma dst_mask;
 356 .
 357 .  {* If this field is non null, then the supplied function is
 358 .     called rather than the normal function.  This allows really
 359 .     strange relocation methods to be accommodated.  *}
 360 .  bfd_reloc_status_type (*special_function)
 361 .    (bfd *, arelent *, struct bfd_symbol *, void *, asection *,
 362 .     bfd *, char **);
 363 .
 364 .  {* The textual name of the relocation type.  *}
 365 .  const char *name;
 366 .};
 367 .
 368 */
 369
 370 /*
 371 FUNCTION
 372         The HOWTO Macro
 373
 374 DESCRIPTION
 375         The HOWTO macro fills in a reloc_howto_type (a typedef for
 376         const struct reloc_howto_struct).
 377
 378 .#define HOWTO(type, right, size, bits, pcrel, left, ovf, func, name,   \
 379 .              inplace, src_mask, dst_mask, pcrel_off)                  \
 380 .  { (unsigned) type, size < 0 ? -size : size, bits, right, left, ovf,  \
 381 .    size < 0, pcrel, inplace, pcrel_off, src_mask, dst_mask, func, name }
 382
 383 DESCRIPTION
 384         This is used to fill in an empty howto entry in an array.
 385
 386 .#define EMPTY_HOWTO(C) \
 387 .  HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \
 388 .         NULL, FALSE, 0, 0, FALSE)
 389 .
 390 */
 391
 392 /*
 393 FUNCTION
 394         bfd_get_reloc_size
 395
 396 SYNOPSIS
 397         unsigned int bfd_get_reloc_size (reloc_howto_type *);
 398
 399 DESCRIPTION
 400         For a reloc_howto_type that operates on a fixed number of bytes,
 401         this returns the number of bytes operated on.
 402  */
 403
 404 unsigned int
 405 bfd_get_reloc_size (reloc_howto_type *howto)
 406 {
 407   switch (howto->size)
 408     {
 409     case 0: return 1;
 410     case 1: return 2;
 411     case 2: return 4;
 412     case 3: return 0;
 413     case 4: return 8;
 414     case 5: return 3;
 415     default: abort ();
 416     }
 417 }
 418
 419 /*
 420 TYPEDEF
 421         arelent_chain
 422
 423 DESCRIPTION
 424
 425         How relocs are tied together in an <<asection>>:
 426
 427 .typedef struct relent_chain
 428 .{
 429 .  arelent relent;
 430 .  struct relent_chain *next;
 431 .}
 432 .arelent_chain;
 433 .
 434 */
 435
 436 /* N_ONES produces N one bits, without undefined behaviour for N
 437    between zero and the number of bits in a bfd_vma.  */
 438 #define N_ONES(n) ((n) == 0 ? 0 : ((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 439
 440 /*
 441 FUNCTION
 442         bfd_check_overflow
 443
 444 SYNOPSIS
 445         bfd_reloc_status_type bfd_check_overflow
 446           (enum complain_overflow how,
 447            unsigned int bitsize,
 448            unsigned int rightshift,
 449            unsigned int addrsize,
 450            bfd_vma relocation);
 451
 452 DESCRIPTION
 453         Perform overflow checking on @var{relocation} which has
 454         @var{bitsize} significant bits and will be shifted right by
 455         @var{rightshift} bits, on a machine with addresses containing
 456         @var{addrsize} significant bits.  The result is either of
 457         @code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
 458
 459 */
 460
 461 bfd_reloc_status_type
 462 bfd_check_overflow (enum complain_overflow how,
 463                     unsigned int bitsize,
 464                     unsigned int rightshift,
 465                     unsigned int addrsize,
 466                     bfd_vma relocation)
 467 {
 468   bfd_vma fieldmask, addrmask, signmask, ss, a;
 469   bfd_reloc_status_type flag = bfd_reloc_ok;
 470
 471   if (bitsize == 0)
 472     return flag;
 473
 474   /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
 475      we'll be permissive: extra bits in the field mask will
 476      automatically extend the address mask for purposes of the
 477      overflow check.  */
 478   fieldmask = N_ONES (bitsize);
 479   signmask = ~fieldmask;
 480   addrmask = N_ONES (addrsize) | (fieldmask << rightshift);
 481   a = (relocation & addrmask) >> rightshift;
 482
 483   switch (how)
 484     {
 485     case complain_overflow_dont:
 486       break;
 487
 488     case complain_overflow_signed:
 489       /* If any sign bits are set, all sign bits must be set.  That
 490          is, A must be a valid negative address after shifting.  */
 491       signmask = ~ (fieldmask >> 1);
 492       /* Fall thru */
 493
 494     case complain_overflow_bitfield:
 495       /* Bitfields are sometimes signed, sometimes unsigned.  We
 496          explicitly allow an address wrap too, which means a bitfield
 497          of n bits is allowed to store -2**n to 2**n-1.  Thus overflow
 498          if the value has some, but not all, bits set outside the
 499          field.  */
 500       ss = a & signmask;
 501       if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
 502         flag = bfd_reloc_overflow;
 503       break;
 504
 505     case complain_overflow_unsigned:
 506       /* We have an overflow if the address does not fit in the field.  */
 507       if ((a & signmask) != 0)
 508         flag = bfd_reloc_overflow;
 509       break;
 510
 511     default:
 512       abort ();
 513     }
 514
 515   return flag;
 516 }
 517
 518 /*
 519 FUNCTION
 520         bfd_reloc_offset_in_range
 521
 522 SYNOPSIS
 523         bfd_boolean bfd_reloc_offset_in_range
 524           (reloc_howto_type *howto,
 525            bfd *abfd,
 526            asection *section,
 527            bfd_size_type offset);
 528
 529 DESCRIPTION
 530         Returns TRUE if the reloc described by @var{HOWTO} can be
 531         applied at @var{OFFSET} octets in @var{SECTION}.
 532
 533 */
 534
 535 /* HOWTO describes a relocation, at offset OCTET.  Return whether the
 536    relocation field is within SECTION of ABFD.  */
 537
 538 bfd_boolean
 539 bfd_reloc_offset_in_range (reloc_howto_type *howto,
 540                            bfd *abfd,
 541                            asection *section,
 542                            bfd_size_type octet)
 543 {
 544   bfd_size_type octet_end = bfd_get_section_limit_octets (abfd, section);
 545   bfd_size_type reloc_size = bfd_get_reloc_size (howto);
 546
 547   /* The reloc field must be contained entirely within the section.
 548      Allow zero length fields (marker relocs or NONE relocs where no
 549      relocation will be performed) at the end of the section.  */
 550   return octet <= octet_end && octet + reloc_size <= octet_end;
 551 }
 552
 553 /* Read and return the section contents at DATA converted to a host
 554    integer (bfd_vma).  The number of bytes read is given by the HOWTO.  */
 555
 556 static bfd_vma
 557 read_reloc (bfd *abfd, bfd_byte *data, reloc_howto_type *howto)
 558 {
 559   switch (howto->size)
 560     {
 561     case 0:
 562       return bfd_get_8 (abfd, data);
 563
 564     case 1:
 565       return bfd_get_16 (abfd, data);
 566
 567     case 2:
 568       return bfd_get_32 (abfd, data);
 569
 570     case 3:
 571       break;
 572
 573 #ifdef BFD64
 574     case 4:
 575       return bfd_get_64 (abfd, data);
 576 #endif
 577
 578     case 5:
 579       return bfd_get_24 (abfd, data);
 580
 581     default:
 582       abort ();
 583     }
 584   return 0;
 585 }
 586
 587 /* Convert VAL to target format and write to DATA.  The number of
 588    bytes written is given by the HOWTO.  */
 589
 590 static void
 591 write_reloc (bfd *abfd, bfd_vma val, bfd_byte *data, reloc_howto_type *howto)
 592 {
 593   switch (howto->size)
 594     {
 595     case 0:
 596       bfd_put_8 (abfd, val, data);
 597       break;
 598
 599     case 1:
 600       bfd_put_16 (abfd, val, data);
 601       break;
 602
 603     case 2:
 604       bfd_put_32 (abfd, val, data);
 605       break;
 606
 607     case 3:
 608       break;
 609
 610 #ifdef BFD64
 611     case 4:
 612       bfd_put_64 (abfd, val, data);
 613       break;
 614 #endif
 615
 616     case 5:
 617       bfd_put_24 (abfd, val, data);
 618       break;
 619
 620     default:
 621       abort ();
 622     }
 623 }
 624
 625 /* Apply RELOCATION value to target bytes at DATA, according to
 626    HOWTO.  */
 627
 628 static void
 629 apply_reloc (bfd *abfd, bfd_byte *data, reloc_howto_type *howto,
 630              bfd_vma relocation)
 631 {
 632   bfd_vma val = read_reloc (abfd, data, howto);
 633
 634   if (howto->negate)
 635     relocation = -relocation;
 636
 637   val = ((val & ~howto->dst_mask)
 638          | (((val & howto->src_mask) + relocation) & howto->dst_mask));
 639
 640   write_reloc (abfd, val, data, howto);
 641 }
 642
 643 /*
 644 FUNCTION
 645         bfd_perform_relocation
 646
 647 SYNOPSIS
 648         bfd_reloc_status_type bfd_perform_relocation
 649           (bfd *abfd,
 650            arelent *reloc_entry,
 651            void *data,
 652            asection *input_section,
 653            bfd *output_bfd,
 654            char **error_message);
 655
 656 DESCRIPTION
 657         If @var{output_bfd} is supplied to this function, the
 658         generated image will be relocatable; the relocations are
 659         copied to the output file after they have been changed to
 660         reflect the new state of the world. There are two ways of
 661         reflecting the results of partial linkage in an output file:
 662         by modifying the output data in place, and by modifying the
 663         relocation record.  Some native formats (e.g., basic a.out and
 664         basic coff) have no way of specifying an addend in the
 665         relocation type, so the addend has to go in the output data.
 666         This is no big deal since in these formats the output data
 667         slot will always be big enough for the addend. Complex reloc
 668         types with addends were invented to solve just this problem.
 669         The @var{error_message} argument is set to an error message if
 670         this return @code{bfd_reloc_dangerous}.
 671
 672 */
 673
 674 bfd_reloc_status_type
 675 bfd_perform_relocation (bfd *abfd,
 676                         arelent *reloc_entry,
 677                         void *data,
 678                         asection *input_section,
 679                         bfd *output_bfd,
 680                         char **error_message)
 681 {
 682   bfd_vma relocation;
 683   bfd_reloc_status_type flag = bfd_reloc_ok;
 684   bfd_size_type octets;
 685   bfd_vma output_base = 0;
 686   reloc_howto_type *howto = reloc_entry->howto;
 687   asection *reloc_target_output_section;
 688   asymbol *symbol;
 689
 690   symbol = *(reloc_entry->sym_ptr_ptr);
 691
 692   /* If we are not producing relocatable output, return an error if
 693      the symbol is not defined.  An undefined weak symbol is
 694      considered to have a value of zero (SVR4 ABI, p. 4-27).  */
 695   if (bfd_is_und_section (symbol->section)
 696       && (symbol->flags & BSF_WEAK) == 0
 697       && output_bfd == NULL)
 698     flag = bfd_reloc_undefined;
 699
 700   /* If there is a function supplied to handle this relocation type,
 701      call it.  It'll return `bfd_reloc_continue' if further processing
 702      can be done.  */
 703   if (howto && howto->special_function)
 704     {
 705       bfd_reloc_status_type cont;
 706
 707       /* Note - we do not call bfd_reloc_offset_in_range here as the
 708          reloc_entry->address field might actually be valid for the
 709          backend concerned.  It is up to the special_function itself
 710          to call bfd_reloc_offset_in_range if needed.  */
 711       cont = howto->special_function (abfd, reloc_entry, symbol, data,
 712                                       input_section, output_bfd,
 713                                       error_message);
 714       if (cont != bfd_reloc_continue)
 715         return cont;
 716     }
 717
 718   if (bfd_is_abs_section (symbol->section)
 719       && output_bfd != NULL)
 720     {
 721       reloc_entry->address += input_section->output_offset;
 722       return bfd_reloc_ok;
 723     }
 724
 725   /* PR 17512: file: 0f67f69d.  */
 726   if (howto == NULL)
 727     return bfd_reloc_undefined;
 728
 729   /* Is the address of the relocation really within the section?  */
 730   octets = reloc_entry->address * bfd_octets_per_byte (abfd, input_section);
 731   if (!bfd_reloc_offset_in_range (howto, abfd, input_section, octets))
 732     return bfd_reloc_outofrange;
 733
 734   /* Work out which section the relocation is targeted at and the
 735      initial relocation command value.  */
 736
 737   /* Get symbol value.  (Common symbols are special.)  */
 738   if (bfd_is_com_section (symbol->section))
 739     relocation = 0;
 740   else
 741     relocation = symbol->value;
 742
 743   reloc_target_output_section = symbol->section->output_section;
 744
 745   /* Convert input-section-relative symbol value to absolute.  */
 746   if ((output_bfd && ! howto->partial_inplace)
 747       || reloc_target_output_section == NULL)
 748     output_base = 0;
 749   else
 750     output_base = reloc_target_output_section->vma;
 751
 752   output_base += symbol->section->output_offset;
 753
 754   /* If symbol addresses are in octets, convert to bytes.  */
 755   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
 756       && (symbol->section->flags & SEC_ELF_OCTETS))
 757     output_base *= bfd_octets_per_byte (abfd, input_section);
 758
 759   relocation += output_base;
 760
 761   /* Add in supplied addend.  */
 762   relocation += reloc_entry->addend;
 763
 764   /* Here the variable relocation holds the final address of the
 765      symbol we are relocating against, plus any addend.  */
 766
 767   if (howto->pc_relative)
 768     {
 769       /* This is a PC relative relocation.  We want to set RELOCATION
 770          to the distance between the address of the symbol and the
 771          location.  RELOCATION is already the address of the symbol.
 772
 773          We start by subtracting the address of the section containing
 774          the location.
 775
 776          If pcrel_offset is set, we must further subtract the position
 777          of the location within the section.  Some targets arrange for
 778          the addend to be the negative of the position of the location
 779          within the section; for example, i386-aout does this.  For
 780          i386-aout, pcrel_offset is FALSE.  Some other targets do not
 781          include the position of the location; for example, ELF.
 782          For those targets, pcrel_offset is TRUE.
 783
 784          If we are producing relocatable output, then we must ensure
 785          that this reloc will be correctly computed when the final
 786          relocation is done.  If pcrel_offset is FALSE we want to wind
 787          up with the negative of the location within the section,
 788          which means we must adjust the existing addend by the change
 789          in the location within the section.  If pcrel_offset is TRUE
 790          we do not want to adjust the existing addend at all.
 791
 792          FIXME: This seems logical to me, but for the case of
 793          producing relocatable output it is not what the code
 794          actually does.  I don't want to change it, because it seems
 795          far too likely that something will break.  */
 796
 797       relocation -=
 798         input_section->output_section->vma + input_section->output_offset;
 799
 800       if (howto->pcrel_offset)
 801         relocation -= reloc_entry->address;
 802     }
 803
 804   if (output_bfd != NULL)
 805     {
 806       if (! howto->partial_inplace)
 807         {
 808           /* This is a partial relocation, and we want to apply the relocation
 809              to the reloc entry rather than the raw data. Modify the reloc
 810              inplace to reflect what we now know.  */
 811           reloc_entry->addend = relocation;
 812           reloc_entry->address += input_section->output_offset;
 813           return flag;
 814         }
 815       else
 816         {
 817           /* This is a partial relocation, but inplace, so modify the
 818              reloc record a bit.
 819
 820              If we've relocated with a symbol with a section, change
 821              into a ref to the section belonging to the symbol.  */
 822
 823           reloc_entry->address += input_section->output_offset;
 824
 825           /* WTF?? */
 826           if (abfd->xvec->flavour == bfd_target_coff_flavour
 827               && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
 828               && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
 829             {
 830               /* For m68k-coff, the addend was being subtracted twice during
 831                  relocation with -r.  Removing the line below this comment
 832                  fixes that problem; see PR 2953.
 833
 834 However, Ian wrote the following, regarding removing the line below,
 835 which explains why it is still enabled:  --djm
 836
 837 If you put a patch like that into BFD you need to check all the COFF
 838 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
 839 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
 840 problem in a different way.  There may very well be a reason that the
 841 code works as it does.
 842
 843 Hmmm.  The first obvious point is that bfd_perform_relocation should
 844 not have any tests that depend upon the flavour.  It's seem like
 845 entirely the wrong place for such a thing.  The second obvious point
 846 is that the current code ignores the reloc addend when producing
 847 relocatable output for COFF.  That's peculiar.  In fact, I really
 848 have no idea what the point of the line you want to remove is.
 849
 850 A typical COFF reloc subtracts the old value of the symbol and adds in
 851 the new value to the location in the object file (if it's a pc
 852 relative reloc it adds the difference between the symbol value and the
 853 location).  When relocating we need to preserve that property.
 854
 855 BFD handles this by setting the addend to the negative of the old
 856 value of the symbol.  Unfortunately it handles common symbols in a
 857 non-standard way (it doesn't subtract the old value) but that's a
 858 different story (we can't change it without losing backward
 859 compatibility with old object files) (coff-i386 does subtract the old
 860 value, to be compatible with existing coff-i386 targets, like SCO).
 861
 862 So everything works fine when not producing relocatable output.  When
 863 we are producing relocatable output, logically we should do exactly
 864 what we do when not producing relocatable output.  Therefore, your
 865 patch is correct.  In fact, it should probably always just set
 866 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
 867 add the value into the object file.  This won't hurt the COFF code,
 868 which doesn't use the addend; I'm not sure what it will do to other
 869 formats (the thing to check for would be whether any formats both use
 870 the addend and set partial_inplace).
 871
 872 When I wanted to make coff-i386 produce relocatable output, I ran
 873 into the problem that you are running into: I wanted to remove that
 874 line.  Rather than risk it, I made the coff-i386 relocs use a special
 875 function; it's coff_i386_reloc in coff-i386.c.  The function
 876 specifically adds the addend field into the object file, knowing that
 877 bfd_perform_relocation is not going to.  If you remove that line, then
 878 coff-i386.c will wind up adding the addend field in twice.  It's
 879 trivial to fix; it just needs to be done.
 880
 881 The problem with removing the line is just that it may break some
 882 working code.  With BFD it's hard to be sure of anything.  The right
 883 way to deal with this is simply to build and test at least all the
 884 supported COFF targets.  It should be straightforward if time and disk
 885 space consuming.  For each target:
 886     1) build the linker
 887     2) generate some executable, and link it using -r (I would
 888        probably use paranoia.o and link against newlib/libc.a, which
 889        for all the supported targets would be available in
 890        /usr/cygnus/progressive/H-host/target/lib/libc.a).
 891     3) make the change to reloc.c
 892     4) rebuild the linker
 893     5) repeat step 2
 894     6) if the resulting object files are the same, you have at least
 895        made it no worse
 896     7) if they are different you have to figure out which version is
 897        right
 898 */
 899               relocation -= reloc_entry->addend;
 900               reloc_entry->addend = 0;
 901             }
 902           else
 903             {
 904               reloc_entry->addend = relocation;
 905             }
 906         }
 907     }
 908   else if (abfd->xvec->flavour == bfd_target_coff_flavour
 909            && (input_section->output_section->owner->xvec->flavour
 910                == bfd_target_elf_flavour)
 911            && strcmp (abfd->xvec->name, "pe-x86-64") == 0
 912            && strcmp (input_section->output_section->owner->xvec->name,
 913                       "elf64-x86-64") == 0)
 914     {
 915       /* NB: bfd_perform_relocation isn't called to generate PE binary.
 916          _bfd_relocate_contents is called instead.  When linking PE
 917          object files to generate ELF output, _bfd_relocate_contents
 918          isn't called and bfd_perform_relocation is used.  We need to
 919          adjust relocation here.  */
 920       relocation -= reloc_entry->addend;
 921       if (howto->type >= R_AMD64_PCRLONG_1
 922           && howto->type <= R_AMD64_PCRLONG_5)
 923         relocation -= (bfd_vma)(howto->type - R_AMD64_PCRLONG);
 924     }
 925
 926   /* FIXME: This overflow checking is incomplete, because the value
 927      might have overflowed before we get here.  For a correct check we
 928      need to compute the value in a size larger than bitsize, but we
 929      can't reasonably do that for a reloc the same size as a host
 930      machine word.
 931      FIXME: We should also do overflow checking on the result after
 932      adding in the value contained in the object file.  */
 933   if (howto->complain_on_overflow != complain_overflow_dont
 934       && flag == bfd_reloc_ok)
 935     flag = bfd_check_overflow (howto->complain_on_overflow,
 936                                howto->bitsize,
 937                                howto->rightshift,
 938                                bfd_arch_bits_per_address (abfd),
 939                                relocation);
 940
 941   /* Either we are relocating all the way, or we don't want to apply
 942      the relocation to the reloc entry (probably because there isn't
 943      any room in the output format to describe addends to relocs).  */
 944
 945   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
 946      (OSF version 1.3, compiler version 3.11).  It miscompiles the
 947      following program:
 948
 949      struct str
 950      {
 951        unsigned int i0;
 952      } s = { 0 };
 953
 954      int
 955      main ()
 956      {
 957        unsigned long x;
 958
 959        x = 0x100000000;
 960        x <<= (unsigned long) s.i0;
 961        if (x == 0)
 962          printf ("failed\n");
 963        else
 964          printf ("succeeded (%lx)\n", x);
 965      }
 966      */
 967
 968   relocation >>= (bfd_vma) howto->rightshift;
 969
 970   /* Shift everything up to where it's going to be used.  */
 971   relocation <<= (bfd_vma) howto->bitpos;
 972
 973   /* Wait for the day when all have the mask in them.  */
 974
 975   /* What we do:
 976      i instruction to be left alone
 977      o offset within instruction
 978      r relocation offset to apply
 979      S src mask
 980      D dst mask
 981      N ~dst mask
 982      A part 1
 983      B part 2
 984      R result
 985
 986      Do this:
 987      ((  i i i i i o o o o o  from bfd_get<size>
 988      and           S S S S S) to get the size offset we want
 989      +   r r r r r r r r r r) to get the final value to place
 990      and           D D D D D  to chop to right size
 991      -----------------------
 992      =             A A A A A
 993      And this:
 994      (   i i i i i o o o o o  from bfd_get<size>
 995      and N N N N N          ) get instruction
 996      -----------------------
 997      =   B B B B B
 998
 999      And then:
1000      (   B B B B B
1001      or            A A A A A)
1002      -----------------------
1003      =   R R R R R R R R R R  put into bfd_put<size>
1004      */
1005
1006   data = (bfd_byte *) data + octets;
1007   apply_reloc (abfd, data, howto, relocation);
1008   return flag;
1009 }
1010
1011 /*
1012 FUNCTION
1013         bfd_install_relocation
1014
1015 SYNOPSIS
1016         bfd_reloc_status_type bfd_install_relocation
1017           (bfd *abfd,
1018            arelent *reloc_entry,
1019            void *data, bfd_vma data_start,
1020            asection *input_section,
1021            char **error_message);
1022
1023 DESCRIPTION
1024         This looks remarkably like <<bfd_perform_relocation>>, except it
1025         does not expect that the section contents have been filled in.
1026         I.e., it's suitable for use when creating, rather than applying
1027         a relocation.
1028
1029         For now, this function should be considered reserved for the
1030         assembler.
1031 */
1032
1033 bfd_reloc_status_type
1034 bfd_install_relocation (bfd *abfd,
1035                         arelent *reloc_entry,
1036                         void *data_start,
1037                         bfd_vma data_start_offset,
1038                         asection *input_section,
1039                         char **error_message)
1040 {
1041   bfd_vma relocation;
1042   bfd_reloc_status_type flag = bfd_reloc_ok;
1043   bfd_size_type octets;
1044   bfd_vma output_base = 0;
1045   reloc_howto_type *howto = reloc_entry->howto;
1046   asection *reloc_target_output_section;
1047   asymbol *symbol;
1048   bfd_byte *data;
1049
1050   symbol = *(reloc_entry->sym_ptr_ptr);
1051
1052   /* If there is a function supplied to handle this relocation type,
1053      call it.  It'll return `bfd_reloc_continue' if further processing
1054      can be done.  */
1055   if (howto && howto->special_function)
1056     {
1057       bfd_reloc_status_type cont;
1058
1059       /* Note - we do not call bfd_reloc_offset_in_range here as the
1060          reloc_entry->address field might actually be valid for the
1061          backend concerned.  It is up to the special_function itself
1062          to call bfd_reloc_offset_in_range if needed.  */
1063       /* XXX - The special_function calls haven't been fixed up to deal
1064          with creating new relocations and section contents.  */
1065       cont = howto->special_function (abfd, reloc_entry, symbol,
1066                                       /* XXX - Non-portable! */
1067                                       ((bfd_byte *) data_start
1068                                        - data_start_offset),
1069                                       input_section, abfd, error_message);
1070       if (cont != bfd_reloc_continue)
1071         return cont;
1072     }
1073
1074   if (bfd_is_abs_section (symbol->section))
1075     {
1076       reloc_entry->address += input_section->output_offset;
1077       return bfd_reloc_ok;
1078     }
1079
1080   /* No need to check for howto != NULL if !bfd_is_abs_section as
1081      it will have been checked in `bfd_perform_relocation already'.  */
1082
1083   /* Is the address of the relocation really within the section?  */
1084   octets = reloc_entry->address * bfd_octets_per_byte (abfd, input_section);
1085   if (!bfd_reloc_offset_in_range (howto, abfd, input_section, octets))
1086     return bfd_reloc_outofrange;
1087
1088   /* Work out which section the relocation is targeted at and the
1089      initial relocation command value.  */
1090
1091   /* Get symbol value.  (Common symbols are special.)  */
1092   if (bfd_is_com_section (symbol->section))
1093     relocation = 0;
1094   else
1095     relocation = symbol->value;
1096
1097   reloc_target_output_section = symbol->section->output_section;
1098
1099   /* Convert input-section-relative symbol value to absolute.  */
1100   if (! howto->partial_inplace)
1101     output_base = 0;
1102   else
1103     output_base = reloc_target_output_section->vma;
1104
1105   output_base += symbol->section->output_offset;
1106
1107   /* If symbol addresses are in octets, convert to bytes.  */
1108   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1109       && (symbol->section->flags & SEC_ELF_OCTETS))
1110     output_base *= bfd_octets_per_byte (abfd, input_section);
1111
1112   relocation += output_base;
1113
1114   /* Add in supplied addend.  */
1115   relocation += reloc_entry->addend;
1116
1117   /* Here the variable relocation holds the final address of the
1118      symbol we are relocating against, plus any addend.  */
1119
1120   if (howto->pc_relative)
1121     {
1122       /* This is a PC relative relocation.  We want to set RELOCATION
1123          to the distance between the address of the symbol and the
1124          location.  RELOCATION is already the address of the symbol.
1125
1126          We start by subtracting the address of the section containing
1127          the location.
1128
1129          If pcrel_offset is set, we must further subtract the position
1130          of the location within the section.  Some targets arrange for
1131          the addend to be the negative of the position of the location
1132          within the section; for example, i386-aout does this.  For
1133          i386-aout, pcrel_offset is FALSE.  Some other targets do not
1134          include the position of the location; for example, ELF.
1135          For those targets, pcrel_offset is TRUE.
1136
1137          If we are producing relocatable output, then we must ensure
1138          that this reloc will be correctly computed when the final
1139          relocation is done.  If pcrel_offset is FALSE we want to wind
1140          up with the negative of the location within the section,
1141          which means we must adjust the existing addend by the change
1142          in the location within the section.  If pcrel_offset is TRUE
1143          we do not want to adjust the existing addend at all.
1144
1145          FIXME: This seems logical to me, but for the case of
1146          producing relocatable output it is not what the code
1147          actually does.  I don't want to change it, because it seems
1148          far too likely that something will break.  */
1149
1150       relocation -=
1151         input_section->output_section->vma + input_section->output_offset;
1152
1153       if (howto->pcrel_offset && howto->partial_inplace)
1154         relocation -= reloc_entry->address;
1155     }
1156
1157   if (! howto->partial_inplace)
1158     {
1159       /* This is a partial relocation, and we want to apply the relocation
1160          to the reloc entry rather than the raw data. Modify the reloc
1161          inplace to reflect what we now know.  */
1162       reloc_entry->addend = relocation;
1163       reloc_entry->address += input_section->output_offset;
1164       return flag;
1165     }
1166   else
1167     {
1168       /* This is a partial relocation, but inplace, so modify the
1169          reloc record a bit.
1170
1171          If we've relocated with a symbol with a section, change
1172          into a ref to the section belonging to the symbol.  */
1173       reloc_entry->address += input_section->output_offset;
1174
1175       /* WTF?? */
1176       if (abfd->xvec->flavour == bfd_target_coff_flavour
1177           && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1178           && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1179         {
1180
1181           /* For m68k-coff, the addend was being subtracted twice during
1182              relocation with -r.  Removing the line below this comment
1183              fixes that problem; see PR 2953.
1184
1185 However, Ian wrote the following, regarding removing the line below,
1186 which explains why it is still enabled:  --djm
1187
1188 If you put a patch like that into BFD you need to check all the COFF
1189 linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
1190 SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1191 problem in a different way.  There may very well be a reason that the
1192 code works as it does.
1193
1194 Hmmm.  The first obvious point is that bfd_install_relocation should
1195 not have any tests that depend upon the flavour.  It's seem like
1196 entirely the wrong place for such a thing.  The second obvious point
1197 is that the current code ignores the reloc addend when producing
1198 relocatable output for COFF.  That's peculiar.  In fact, I really
1199 have no idea what the point of the line you want to remove is.
1200
1201 A typical COFF reloc subtracts the old value of the symbol and adds in
1202 the new value to the location in the object file (if it's a pc
1203 relative reloc it adds the difference between the symbol value and the
1204 location).  When relocating we need to preserve that property.
1205
1206 BFD handles this by setting the addend to the negative of the old
1207 value of the symbol.  Unfortunately it handles common symbols in a
1208 non-standard way (it doesn't subtract the old value) but that's a
1209 different story (we can't change it without losing backward
1210 compatibility with old object files) (coff-i386 does subtract the old
1211 value, to be compatible with existing coff-i386 targets, like SCO).
1212
1213 So everything works fine when not producing relocatable output.  When
1214 we are producing relocatable output, logically we should do exactly
1215 what we do when not producing relocatable output.  Therefore, your
1216 patch is correct.  In fact, it should probably always just set
1217 reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1218 add the value into the object file.  This won't hurt the COFF code,
1219 which doesn't use the addend; I'm not sure what it will do to other
1220 formats (the thing to check for would be whether any formats both use
1221 the addend and set partial_inplace).
1222
1223 When I wanted to make coff-i386 produce relocatable output, I ran
1224 into the problem that you are running into: I wanted to remove that
1225 line.  Rather than risk it, I made the coff-i386 relocs use a special
1226 function; it's coff_i386_reloc in coff-i386.c.  The function
1227 specifically adds the addend field into the object file, knowing that
1228 bfd_install_relocation is not going to.  If you remove that line, then
1229 coff-i386.c will wind up adding the addend field in twice.  It's
1230 trivial to fix; it just needs to be done.
1231
1232 The problem with removing the line is just that it may break some
1233 working code.  With BFD it's hard to be sure of anything.  The right
1234 way to deal with this is simply to build and test at least all the
1235 supported COFF targets.  It should be straightforward if time and disk
1236 space consuming.  For each target:
1237     1) build the linker
1238     2) generate some executable, and link it using -r (I would
1239        probably use paranoia.o and link against newlib/libc.a, which
1240        for all the supported targets would be available in
1241        /usr/cygnus/progressive/H-host/target/lib/libc.a).
1242     3) make the change to reloc.c
1243     4) rebuild the linker
1244     5) repeat step 2
1245     6) if the resulting object files are the same, you have at least
1246        made it no worse
1247     7) if they are different you have to figure out which version is
1248        right.  */
1249           relocation -= reloc_entry->addend;
1250           /* FIXME: There should be no target specific code here...  */
1251           if (strcmp (abfd->xvec->name, "coff-z8k") != 0)
1252             reloc_entry->addend = 0;
1253         }
1254       else
1255         {
1256           reloc_entry->addend = relocation;
1257         }
1258     }
1259
1260   /* FIXME: This overflow checking is incomplete, because the value
1261      might have overflowed before we get here.  For a correct check we
1262      need to compute the value in a size larger than bitsize, but we
1263      can't reasonably do that for a reloc the same size as a host
1264      machine word.
1265      FIXME: We should also do overflow checking on the result after
1266      adding in the value contained in the object file.  */
1267   if (howto->complain_on_overflow != complain_overflow_dont)
1268     flag = bfd_check_overflow (howto->complain_on_overflow,
1269                                howto->bitsize,
1270                                howto->rightshift,
1271                                bfd_arch_bits_per_address (abfd),
1272                                relocation);
1273
1274   /* Either we are relocating all the way, or we don't want to apply
1275      the relocation to the reloc entry (probably because there isn't
1276      any room in the output format to describe addends to relocs).  */
1277
1278   /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1279      (OSF version 1.3, compiler version 3.11).  It miscompiles the
1280      following program:
1281
1282      struct str
1283      {
1284        unsigned int i0;
1285      } s = { 0 };
1286
1287      int
1288      main ()
1289      {
1290        unsigned long x;
1291
1292        x = 0x100000000;
1293        x <<= (unsigned long) s.i0;
1294        if (x == 0)
1295          printf ("failed\n");
1296        else
1297          printf ("succeeded (%lx)\n", x);
1298      }
1299      */
1300
1301   relocation >>= (bfd_vma) howto->rightshift;
1302
1303   /* Shift everything up to where it's going to be used.  */
1304   relocation <<= (bfd_vma) howto->bitpos;
1305
1306   /* Wait for the day when all have the mask in them.  */
1307
1308   /* What we do:
1309      i instruction to be left alone
1310      o offset within instruction
1311      r relocation offset to apply
1312      S src mask
1313      D dst mask
1314      N ~dst mask
1315      A part 1
1316      B part 2
1317      R result
1318
1319      Do this:
1320      ((  i i i i i o o o o o  from bfd_get<size>
1321      and           S S S S S) to get the size offset we want
1322      +   r r r r r r r r r r) to get the final value to place
1323      and           D D D D D  to chop to right size
1324      -----------------------
1325      =             A A A A A
1326      And this:
1327      (   i i i i i o o o o o  from bfd_get<size>
1328      and N N N N N          ) get instruction
1329      -----------------------
1330      =   B B B B B
1331
1332      And then:
1333      (   B B B B B
1334      or            A A A A A)
1335      -----------------------
1336      =   R R R R R R R R R R  put into bfd_put<size>
1337      */
1338
1339   data = (bfd_byte *) data_start + (octets - data_start_offset);
1340   apply_reloc (abfd, data, howto, relocation);
1341   return flag;
1342 }
1343
1344 /* This relocation routine is used by some of the backend linkers.
1345    They do not construct asymbol or arelent structures, so there is no
1346    reason for them to use bfd_perform_relocation.  Also,
1347    bfd_perform_relocation is so hacked up it is easier to write a new
1348    function than to try to deal with it.
1349
1350    This routine does a final relocation.  Whether it is useful for a
1351    relocatable link depends upon how the object format defines
1352    relocations.
1353
1354    FIXME: This routine ignores any special_function in the HOWTO,
1355    since the existing special_function values have been written for
1356    bfd_perform_relocation.
1357
1358    HOWTO is the reloc howto information.
1359    INPUT_BFD is the BFD which the reloc applies to.
1360    INPUT_SECTION is the section which the reloc applies to.
1361    CONTENTS is the contents of the section.
1362    ADDRESS is the address of the reloc within INPUT_SECTION.
1363    VALUE is the value of the symbol the reloc refers to.
1364    ADDEND is the addend of the reloc.  */
1365
1366 bfd_reloc_status_type
1367 _bfd_final_link_relocate (reloc_howto_type *howto,
1368                           bfd *input_bfd,
1369                           asection *input_section,
1370                           bfd_byte *contents,
1371                           bfd_vma address,
1372                           bfd_vma value,
1373                           bfd_vma addend)
1374 {
1375   bfd_vma relocation;
1376   bfd_size_type octets = (address
1377                           * bfd_octets_per_byte (input_bfd, input_section));
1378
1379   /* Sanity check the address.  */
1380   if (!bfd_reloc_offset_in_range (howto, input_bfd, input_section, octets))
1381     return bfd_reloc_outofrange;
1382
1383   /* This function assumes that we are dealing with a basic relocation
1384      against a symbol.  We want to compute the value of the symbol to
1385      relocate to.  This is just VALUE, the value of the symbol, plus
1386      ADDEND, any addend associated with the reloc.  */
1387   relocation = value + addend;
1388
1389   /* If the relocation is PC relative, we want to set RELOCATION to
1390      the distance between the symbol (currently in RELOCATION) and the
1391      location we are relocating.  Some targets (e.g., i386-aout)
1392      arrange for the contents of the section to be the negative of the
1393      offset of the location within the section; for such targets
1394      pcrel_offset is FALSE.  Other targets (e.g., ELF) simply leave
1395      the contents of the section as zero; for such targets
1396      pcrel_offset is TRUE.  If pcrel_offset is FALSE we do not need to
1397      subtract out the offset of the location within the section (which
1398      is just ADDRESS).  */
1399   if (howto->pc_relative)
1400     {
1401       relocation -= (input_section->output_section->vma
1402                      + input_section->output_offset);
1403       if (howto->pcrel_offset)
1404         relocation -= address;
1405     }
1406
1407   return _bfd_relocate_contents (howto, input_bfd, relocation,
1408                                  contents + octets);
1409 }
1410
1411 /* Relocate a given location using a given value and howto.  */
1412
1413 bfd_reloc_status_type
1414 _bfd_relocate_contents (reloc_howto_type *howto,
1415                         bfd *input_bfd,
1416                         bfd_vma relocation,
1417                         bfd_byte *location)
1418 {
1419   bfd_vma x;
1420   bfd_reloc_status_type flag;
1421   unsigned int rightshift = howto->rightshift;
1422   unsigned int bitpos = howto->bitpos;
1423
1424   if (howto->negate)
1425     relocation = -relocation;
1426
1427   /* Get the value we are going to relocate.  */
1428   x = read_reloc (input_bfd, location, howto);
1429
1430   /* Check for overflow.  FIXME: We may drop bits during the addition
1431      which we don't check for.  We must either check at every single
1432      operation, which would be tedious, or we must do the computations
1433      in a type larger than bfd_vma, which would be inefficient.  */
1434   flag = bfd_reloc_ok;
1435   if (howto->complain_on_overflow != complain_overflow_dont)
1436     {
1437       bfd_vma addrmask, fieldmask, signmask, ss;
1438       bfd_vma a, b, sum;
1439
1440       /* Get the values to be added together.  For signed and unsigned
1441          relocations, we assume that all values should be truncated to
1442          the size of an address.  For bitfields, all the bits matter.
1443          See also bfd_check_overflow.  */
1444       fieldmask = N_ONES (howto->bitsize);
1445       signmask = ~fieldmask;
1446       addrmask = (N_ONES (bfd_arch_bits_per_address (input_bfd))
1447                   | (fieldmask << rightshift));
1448       a = (relocation & addrmask) >> rightshift;
1449       b = (x & howto->src_mask & addrmask) >> bitpos;
1450       addrmask >>= rightshift;
1451
1452       switch (howto->complain_on_overflow)
1453         {
1454         case complain_overflow_signed:
1455           /* If any sign bits are set, all sign bits must be set.
1456              That is, A must be a valid negative address after
1457              shifting.  */
1458           signmask = ~(fieldmask >> 1);
1459           /* Fall thru */
1460
1461         case complain_overflow_bitfield:
1462           /* Much like the signed check, but for a field one bit
1463              wider.  We allow a bitfield to represent numbers in the
1464              range -2**n to 2**n-1, where n is the number of bits in the
1465              field.  Note that when bfd_vma is 32 bits, a 32-bit reloc
1466              can't overflow, which is exactly what we want.  */
1467           ss = a & signmask;
1468           if (ss != 0 && ss != (addrmask & signmask))
1469             flag = bfd_reloc_overflow;
1470
1471           /* We only need this next bit of code if the sign bit of B
1472              is below the sign bit of A.  This would only happen if
1473              SRC_MASK had fewer bits than BITSIZE.  Note that if
1474              SRC_MASK has more bits than BITSIZE, we can get into
1475              trouble; we would need to verify that B is in range, as
1476              we do for A above.  */
1477           ss = ((~howto->src_mask) >> 1) & howto->src_mask;
1478           ss >>= bitpos;
1479
1480           /* Set all the bits above the sign bit.  */
1481           b = (b ^ ss) - ss;
1482
1483           /* Now we can do the addition.  */
1484           sum = a + b;
1485
1486           /* See if the result has the correct sign.  Bits above the
1487              sign bit are junk now; ignore them.  If the sum is
1488              positive, make sure we did not have all negative inputs;
1489              if the sum is negative, make sure we did not have all
1490              positive inputs.  The test below looks only at the sign
1491              bits, and it really just
1492                  SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1493
1494              We mask with addrmask here to explicitly allow an address
1495              wrap-around.  The Linux kernel relies on it, and it is
1496              the only way to write assembler code which can run when
1497              loaded at a location 0x80000000 away from the location at
1498              which it is linked.  */
1499           if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
1500             flag = bfd_reloc_overflow;
1501           break;
1502
1503         case complain_overflow_unsigned:
1504           /* Checking for an unsigned overflow is relatively easy:
1505              trim the addresses and add, and trim the result as well.
1506              Overflow is normally indicated when the result does not
1507              fit in the field.  However, we also need to consider the
1508              case when, e.g., fieldmask is 0x7fffffff or smaller, an
1509              input is 0x80000000, and bfd_vma is only 32 bits; then we
1510              will get sum == 0, but there is an overflow, since the
1511              inputs did not fit in the field.  Instead of doing a
1512              separate test, we can check for this by or-ing in the
1513              operands when testing for the sum overflowing its final
1514              field.  */
1515           sum = (a + b) & addrmask;
1516           if ((a | b | sum) & signmask)
1517             flag = bfd_reloc_overflow;
1518           break;
1519
1520         default:
1521           abort ();
1522         }
1523     }
1524
1525   /* Put RELOCATION in the right bits.  */
1526   relocation >>= (bfd_vma) rightshift;
1527   relocation <<= (bfd_vma) bitpos;
1528
1529   /* Add RELOCATION to the right bits of X.  */
1530   x = ((x & ~howto->dst_mask)
1531        | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1532
1533   /* Put the relocated value back in the object file.  */
1534   write_reloc (input_bfd, x, location, howto);
1535   return flag;
1536 }
1537
1538 /* Clear a given location using a given howto, by applying a fixed relocation
1539    value and discarding any in-place addend.  This is used for fixed-up
1540    relocations against discarded symbols, to make ignorable debug or unwind
1541    information more obvious.  */
1542
1543 bfd_reloc_status_type
1544 _bfd_clear_contents (reloc_howto_type *howto,
1545                      bfd *input_bfd,
1546                      asection *input_section,
1547                      bfd_byte *buf,
1548                      bfd_vma off)
1549 {
1550   bfd_vma x;
1551   bfd_byte *location;
1552
1553   if (!bfd_reloc_offset_in_range (howto, input_bfd, input_section, off))
1554     return bfd_reloc_outofrange;
1555
1556   /* Get the value we are going to relocate.  */
1557   location = buf + off;
1558   x = read_reloc (input_bfd, location, howto);
1559
1560   /* Zero out the unwanted bits of X.  */
1561   x &= ~howto->dst_mask;
1562
1563   /* For a range list, use 1 instead of 0 as placeholder.  0
1564      would terminate the list, hiding any later entries.  */
1565   if (strcmp (bfd_section_name (input_section), ".debug_ranges") == 0
1566       && (howto->dst_mask & 1) != 0)
1567     x |= 1;
1568
1569   /* Put the relocated value back in the object file.  */
1570   write_reloc (input_bfd, x, location, howto);
1571   return bfd_reloc_ok;
1572 }
1573
1574 /*
1575 DOCDD
1576 INODE
1577         howto manager,  , typedef arelent, Relocations
1578
1579 SUBSECTION
1580         The howto manager
1581
1582         When an application wants to create a relocation, but doesn't
1583         know what the target machine might call it, it can find out by
1584         using this bit of code.
1585
1586 */
1587
1588 /*
1589 TYPEDEF
1590         bfd_reloc_code_type
1591
1592 DESCRIPTION
1593         The insides of a reloc code.  The idea is that, eventually, there
1594         will be one enumerator for every type of relocation we ever do.
1595         Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1596         return a howto pointer.
1597
1598         This does mean that the application must determine the correct
1599         enumerator value; you can't get a howto pointer from a random set
1600         of attributes.
1601
1602 SENUM
1603    bfd_reloc_code_real
1604
1605 ENUM
1606   BFD_RELOC_64
1607 ENUMX
1608   BFD_RELOC_32
1609 ENUMX
1610   BFD_RELOC_26
1611 ENUMX
1612   BFD_RELOC_24
1613 ENUMX
1614   BFD_RELOC_16
1615 ENUMX
1616   BFD_RELOC_14
1617 ENUMX
1618   BFD_RELOC_8
1619 ENUMDOC
1620   Basic absolute relocations of N bits.
1621
1622 ENUM
1623   BFD_RELOC_64_PCREL
1624 ENUMX
1625   BFD_RELOC_32_PCREL
1626 ENUMX
1627   BFD_RELOC_24_PCREL
1628 ENUMX
1629   BFD_RELOC_16_PCREL
1630 ENUMX
1631   BFD_RELOC_12_PCREL
1632 ENUMX
1633   BFD_RELOC_8_PCREL
1634 ENUMDOC
1635   PC-relative relocations.  Sometimes these are relative to the address
1636 of the relocation itself; sometimes they are relative to the start of
1637 the section containing the relocation.  It depends on the specific target.
1638
1639 ENUM
1640   BFD_RELOC_32_SECREL
1641 ENUMDOC
1642   Section relative relocations.  Some targets need this for DWARF2.
1643
1644 ENUM
1645   BFD_RELOC_32_GOT_PCREL
1646 ENUMX
1647   BFD_RELOC_16_GOT_PCREL
1648 ENUMX
1649   BFD_RELOC_8_GOT_PCREL
1650 ENUMX
1651   BFD_RELOC_32_GOTOFF
1652 ENUMX
1653   BFD_RELOC_16_GOTOFF
1654 ENUMX
1655   BFD_RELOC_LO16_GOTOFF
1656 ENUMX
1657   BFD_RELOC_HI16_GOTOFF
1658 ENUMX
1659   BFD_RELOC_HI16_S_GOTOFF
1660 ENUMX
1661   BFD_RELOC_8_GOTOFF
1662 ENUMX
1663   BFD_RELOC_64_PLT_PCREL
1664 ENUMX
1665   BFD_RELOC_32_PLT_PCREL
1666 ENUMX
1667   BFD_RELOC_24_PLT_PCREL
1668 ENUMX
1669   BFD_RELOC_16_PLT_PCREL
1670 ENUMX
1671   BFD_RELOC_8_PLT_PCREL
1672 ENUMX
1673   BFD_RELOC_64_PLTOFF
1674 ENUMX
1675   BFD_RELOC_32_PLTOFF
1676 ENUMX
1677   BFD_RELOC_16_PLTOFF
1678 ENUMX
1679   BFD_RELOC_LO16_PLTOFF
1680 ENUMX
1681   BFD_RELOC_HI16_PLTOFF
1682 ENUMX
1683   BFD_RELOC_HI16_S_PLTOFF
1684 ENUMX
1685   BFD_RELOC_8_PLTOFF
1686 ENUMDOC
1687   For ELF.
1688
1689 ENUM
1690   BFD_RELOC_SIZE32
1691 ENUMX
1692   BFD_RELOC_SIZE64
1693 ENUMDOC
1694   Size relocations.
1695
1696 ENUM
1697   BFD_RELOC_68K_GLOB_DAT
1698 ENUMX
1699   BFD_RELOC_68K_JMP_SLOT
1700 ENUMX
1701   BFD_RELOC_68K_RELATIVE
1702 ENUMX
1703   BFD_RELOC_68K_TLS_GD32
1704 ENUMX
1705   BFD_RELOC_68K_TLS_GD16
1706 ENUMX
1707   BFD_RELOC_68K_TLS_GD8
1708 ENUMX
1709   BFD_RELOC_68K_TLS_LDM32
1710 ENUMX
1711   BFD_RELOC_68K_TLS_LDM16
1712 ENUMX
1713   BFD_RELOC_68K_TLS_LDM8
1714 ENUMX
1715   BFD_RELOC_68K_TLS_LDO32
1716 ENUMX
1717   BFD_RELOC_68K_TLS_LDO16
1718 ENUMX
1719   BFD_RELOC_68K_TLS_LDO8
1720 ENUMX
1721   BFD_RELOC_68K_TLS_IE32
1722 ENUMX
1723   BFD_RELOC_68K_TLS_IE16
1724 ENUMX
1725   BFD_RELOC_68K_TLS_IE8
1726 ENUMX
1727   BFD_RELOC_68K_TLS_LE32
1728 ENUMX
1729   BFD_RELOC_68K_TLS_LE16
1730 ENUMX
1731   BFD_RELOC_68K_TLS_LE8
1732 ENUMDOC
1733   Relocations used by 68K ELF.
1734
1735 ENUM
1736   BFD_RELOC_32_BASEREL
1737 ENUMX
1738   BFD_RELOC_16_BASEREL
1739 ENUMX
1740   BFD_RELOC_LO16_BASEREL
1741 ENUMX
1742   BFD_RELOC_HI16_BASEREL
1743 ENUMX
1744   BFD_RELOC_HI16_S_BASEREL
1745 ENUMX
1746   BFD_RELOC_8_BASEREL
1747 ENUMX
1748   BFD_RELOC_RVA
1749 ENUMDOC
1750   Linkage-table relative.
1751
1752 ENUM
1753   BFD_RELOC_8_FFnn
1754 ENUMDOC
1755   Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1756
1757 ENUM
1758   BFD_RELOC_32_PCREL_S2
1759 ENUMX
1760   BFD_RELOC_16_PCREL_S2
1761 ENUMX
1762   BFD_RELOC_23_PCREL_S2
1763 ENUMDOC
1764   These PC-relative relocations are stored as word displacements --
1765 i.e., byte displacements shifted right two bits.  The 30-bit word
1766 displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1767 SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
1768 signed 16-bit displacement is used on the MIPS, and the 23-bit
1769 displacement is used on the Alpha.
1770
1771 ENUM
1772   BFD_RELOC_HI22
1773 ENUMX
1774   BFD_RELOC_LO10
1775 ENUMDOC
1776   High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1777 the target word.  These are used on the SPARC.
1778
1779 ENUM
1780   BFD_RELOC_GPREL16
1781 ENUMX
1782   BFD_RELOC_GPREL32
1783 ENUMDOC
1784   For systems that allocate a Global Pointer register, these are
1785 displacements off that register.  These relocation types are
1786 handled specially, because the value the register will have is
1787 decided relatively late.
1788
1789 ENUM
1790   BFD_RELOC_NONE
1791 ENUMX
1792   BFD_RELOC_SPARC_WDISP22
1793 ENUMX
1794   BFD_RELOC_SPARC22
1795 ENUMX
1796   BFD_RELOC_SPARC13
1797 ENUMX
1798   BFD_RELOC_SPARC_GOT10
1799 ENUMX
1800   BFD_RELOC_SPARC_GOT13
1801 ENUMX
1802   BFD_RELOC_SPARC_GOT22
1803 ENUMX
1804   BFD_RELOC_SPARC_PC10
1805 ENUMX
1806   BFD_RELOC_SPARC_PC22
1807 ENUMX
1808   BFD_RELOC_SPARC_WPLT30
1809 ENUMX
1810   BFD_RELOC_SPARC_COPY
1811 ENUMX
1812   BFD_RELOC_SPARC_GLOB_DAT
1813 ENUMX
1814   BFD_RELOC_SPARC_JMP_SLOT
1815 ENUMX
1816   BFD_RELOC_SPARC_RELATIVE
1817 ENUMX
1818   BFD_RELOC_SPARC_UA16
1819 ENUMX
1820   BFD_RELOC_SPARC_UA32
1821 ENUMX
1822   BFD_RELOC_SPARC_UA64
1823 ENUMX
1824   BFD_RELOC_SPARC_GOTDATA_HIX22
1825 ENUMX
1826   BFD_RELOC_SPARC_GOTDATA_LOX10
1827 ENUMX
1828   BFD_RELOC_SPARC_GOTDATA_OP_HIX22
1829 ENUMX
1830   BFD_RELOC_SPARC_GOTDATA_OP_LOX10
1831 ENUMX
1832   BFD_RELOC_SPARC_GOTDATA_OP
1833 ENUMX
1834   BFD_RELOC_SPARC_JMP_IREL
1835 ENUMX
1836   BFD_RELOC_SPARC_IRELATIVE
1837 ENUMDOC
1838   SPARC ELF relocations.  There is probably some overlap with other
1839   relocation types already defined.
1840
1841 ENUM
1842   BFD_RELOC_SPARC_BASE13
1843 ENUMX
1844   BFD_RELOC_SPARC_BASE22
1845 ENUMDOC
1846   I think these are specific to SPARC a.out (e.g., Sun 4).
1847
1848 ENUMEQ
1849   BFD_RELOC_SPARC_64
1850   BFD_RELOC_64
1851 ENUMX
1852   BFD_RELOC_SPARC_10
1853 ENUMX
1854   BFD_RELOC_SPARC_11
1855 ENUMX
1856   BFD_RELOC_SPARC_OLO10
1857 ENUMX
1858   BFD_RELOC_SPARC_HH22
1859 ENUMX
1860   BFD_RELOC_SPARC_HM10
1861 ENUMX
1862   BFD_RELOC_SPARC_LM22
1863 ENUMX
1864   BFD_RELOC_SPARC_PC_HH22
1865 ENUMX
1866   BFD_RELOC_SPARC_PC_HM10
1867 ENUMX
1868   BFD_RELOC_SPARC_PC_LM22
1869 ENUMX
1870   BFD_RELOC_SPARC_WDISP16
1871 ENUMX
1872   BFD_RELOC_SPARC_WDISP19
1873 ENUMX
1874   BFD_RELOC_SPARC_7
1875 ENUMX
1876   BFD_RELOC_SPARC_6
1877 ENUMX
1878   BFD_RELOC_SPARC_5
1879 ENUMEQX
1880   BFD_RELOC_SPARC_DISP64
1881   BFD_RELOC_64_PCREL
1882 ENUMX
1883   BFD_RELOC_SPARC_PLT32
1884 ENUMX
1885   BFD_RELOC_SPARC_PLT64
1886 ENUMX
1887   BFD_RELOC_SPARC_HIX22
1888 ENUMX
1889   BFD_RELOC_SPARC_LOX10
1890 ENUMX
1891   BFD_RELOC_SPARC_H44
1892 ENUMX
1893   BFD_RELOC_SPARC_M44
1894 ENUMX
1895   BFD_RELOC_SPARC_L44
1896 ENUMX
1897   BFD_RELOC_SPARC_REGISTER
1898 ENUMX
1899   BFD_RELOC_SPARC_H34
1900 ENUMX
1901   BFD_RELOC_SPARC_SIZE32
1902 ENUMX
1903   BFD_RELOC_SPARC_SIZE64
1904 ENUMX
1905   BFD_RELOC_SPARC_WDISP10
1906 ENUMDOC
1907   SPARC64 relocations
1908
1909 ENUM
1910   BFD_RELOC_SPARC_REV32
1911 ENUMDOC
1912   SPARC little endian relocation
1913 ENUM
1914   BFD_RELOC_SPARC_TLS_GD_HI22
1915 ENUMX
1916   BFD_RELOC_SPARC_TLS_GD_LO10
1917 ENUMX
1918   BFD_RELOC_SPARC_TLS_GD_ADD
1919 ENUMX
1920   BFD_RELOC_SPARC_TLS_GD_CALL
1921 ENUMX
1922   BFD_RELOC_SPARC_TLS_LDM_HI22
1923 ENUMX
1924   BFD_RELOC_SPARC_TLS_LDM_LO10
1925 ENUMX
1926   BFD_RELOC_SPARC_TLS_LDM_ADD
1927 ENUMX
1928   BFD_RELOC_SPARC_TLS_LDM_CALL
1929 ENUMX
1930   BFD_RELOC_SPARC_TLS_LDO_HIX22
1931 ENUMX
1932   BFD_RELOC_SPARC_TLS_LDO_LOX10
1933 ENUMX
1934   BFD_RELOC_SPARC_TLS_LDO_ADD
1935 ENUMX
1936   BFD_RELOC_SPARC_TLS_IE_HI22
1937 ENUMX
1938   BFD_RELOC_SPARC_TLS_IE_LO10
1939 ENUMX
1940   BFD_RELOC_SPARC_TLS_IE_LD
1941 ENUMX
1942   BFD_RELOC_SPARC_TLS_IE_LDX
1943 ENUMX
1944   BFD_RELOC_SPARC_TLS_IE_ADD
1945 ENUMX
1946   BFD_RELOC_SPARC_TLS_LE_HIX22
1947 ENUMX
1948   BFD_RELOC_SPARC_TLS_LE_LOX10
1949 ENUMX
1950   BFD_RELOC_SPARC_TLS_DTPMOD32
1951 ENUMX
1952   BFD_RELOC_SPARC_TLS_DTPMOD64
1953 ENUMX
1954   BFD_RELOC_SPARC_TLS_DTPOFF32
1955 ENUMX
1956   BFD_RELOC_SPARC_TLS_DTPOFF64
1957 ENUMX
1958   BFD_RELOC_SPARC_TLS_TPOFF32
1959 ENUMX
1960   BFD_RELOC_SPARC_TLS_TPOFF64
1961 ENUMDOC
1962   SPARC TLS relocations
1963
1964 ENUM
1965   BFD_RELOC_SPU_IMM7
1966 ENUMX
1967   BFD_RELOC_SPU_IMM8
1968 ENUMX
1969   BFD_RELOC_SPU_IMM10
1970 ENUMX
1971   BFD_RELOC_SPU_IMM10W
1972 ENUMX
1973   BFD_RELOC_SPU_IMM16
1974 ENUMX
1975   BFD_RELOC_SPU_IMM16W
1976 ENUMX
1977   BFD_RELOC_SPU_IMM18
1978 ENUMX
1979   BFD_RELOC_SPU_PCREL9a
1980 ENUMX
1981   BFD_RELOC_SPU_PCREL9b
1982 ENUMX
1983   BFD_RELOC_SPU_PCREL16
1984 ENUMX
1985   BFD_RELOC_SPU_LO16
1986 ENUMX
1987   BFD_RELOC_SPU_HI16
1988 ENUMX
1989   BFD_RELOC_SPU_PPU32
1990 ENUMX
1991   BFD_RELOC_SPU_PPU64
1992 ENUMX
1993   BFD_RELOC_SPU_ADD_PIC
1994 ENUMDOC
1995   SPU Relocations.
1996
1997 ENUM
1998   BFD_RELOC_ALPHA_GPDISP_HI16
1999 ENUMDOC
2000   Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
2001      "addend" in some special way.
2002   For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
2003      writing; when reading, it will be the absolute section symbol.  The
2004      addend is the displacement in bytes of the "lda" instruction from
2005      the "ldah" instruction (which is at the address of this reloc).
2006 ENUM
2007   BFD_RELOC_ALPHA_GPDISP_LO16
2008 ENUMDOC
2009   For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
2010      with GPDISP_HI16 relocs.  The addend is ignored when writing the
2011      relocations out, and is filled in with the file's GP value on
2012      reading, for convenience.
2013
2014 ENUM
2015   BFD_RELOC_ALPHA_GPDISP
2016 ENUMDOC
2017   The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
2018      relocation except that there is no accompanying GPDISP_LO16
2019      relocation.
2020
2021 ENUM
2022   BFD_RELOC_ALPHA_LITERAL
2023 ENUMX
2024   BFD_RELOC_ALPHA_ELF_LITERAL
2025 ENUMX
2026   BFD_RELOC_ALPHA_LITUSE
2027 ENUMDOC
2028   The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
2029      the assembler turns it into a LDQ instruction to load the address of
2030      the symbol, and then fills in a register in the real instruction.
2031
2032      The LITERAL reloc, at the LDQ instruction, refers to the .lita
2033      section symbol.  The addend is ignored when writing, but is filled
2034      in with the file's GP value on reading, for convenience, as with the
2035      GPDISP_LO16 reloc.
2036
2037      The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
2038      It should refer to the symbol to be referenced, as with 16_GOTOFF,
2039      but it generates output not based on the position within the .got
2040      section, but relative to the GP value chosen for the file during the
2041      final link stage.
2042
2043      The LITUSE reloc, on the instruction using the loaded address, gives
2044      information to the linker that it might be able to use to optimize
2045      away some literal section references.  The symbol is ignored (read
2046      as the absolute section symbol), and the "addend" indicates the type
2047      of instruction using the register:
2048               1 - "memory" fmt insn
2049               2 - byte-manipulation (byte offset reg)
2050               3 - jsr (target of branch)
2051
2052 ENUM
2053   BFD_RELOC_ALPHA_HINT
2054 ENUMDOC
2055   The HINT relocation indicates a value that should be filled into the
2056      "hint" field of a jmp/jsr/ret instruction, for possible branch-
2057      prediction logic which may be provided on some processors.
2058
2059 ENUM
2060   BFD_RELOC_ALPHA_LINKAGE
2061 ENUMDOC
2062   The LINKAGE relocation outputs a linkage pair in the object file,
2063      which is filled by the linker.
2064
2065 ENUM
2066   BFD_RELOC_ALPHA_CODEADDR
2067 ENUMDOC
2068   The CODEADDR relocation outputs a STO_CA in the object file,
2069      which is filled by the linker.
2070
2071 ENUM
2072   BFD_RELOC_ALPHA_GPREL_HI16
2073 ENUMX
2074   BFD_RELOC_ALPHA_GPREL_LO16
2075 ENUMDOC
2076   The GPREL_HI/LO relocations together form a 32-bit offset from the
2077      GP register.
2078
2079 ENUM
2080   BFD_RELOC_ALPHA_BRSGP
2081 ENUMDOC
2082   Like BFD_RELOC_23_PCREL_S2, except that the source and target must
2083   share a common GP, and the target address is adjusted for
2084   STO_ALPHA_STD_GPLOAD.
2085
2086 ENUM
2087   BFD_RELOC_ALPHA_NOP
2088 ENUMDOC
2089   The NOP relocation outputs a NOP if the longword displacement
2090      between two procedure entry points is < 2^21.
2091
2092 ENUM
2093   BFD_RELOC_ALPHA_BSR
2094 ENUMDOC
2095   The BSR relocation outputs a BSR if the longword displacement
2096      between two procedure entry points is < 2^21.
2097
2098 ENUM
2099   BFD_RELOC_ALPHA_LDA
2100 ENUMDOC
2101   The LDA relocation outputs a LDA if the longword displacement
2102      between two procedure entry points is < 2^16.
2103
2104 ENUM
2105   BFD_RELOC_ALPHA_BOH
2106 ENUMDOC
2107   The BOH relocation outputs a BSR if the longword displacement
2108      between two procedure entry points is < 2^21, or else a hint.
2109
2110 ENUM
2111   BFD_RELOC_ALPHA_TLSGD
2112 ENUMX
2113   BFD_RELOC_ALPHA_TLSLDM
2114 ENUMX
2115   BFD_RELOC_ALPHA_DTPMOD64
2116 ENUMX
2117   BFD_RELOC_ALPHA_GOTDTPREL16
2118 ENUMX
2119   BFD_RELOC_ALPHA_DTPREL64
2120 ENUMX
2121   BFD_RELOC_ALPHA_DTPREL_HI16
2122 ENUMX
2123   BFD_RELOC_ALPHA_DTPREL_LO16
2124 ENUMX
2125   BFD_RELOC_ALPHA_DTPREL16
2126 ENUMX
2127   BFD_RELOC_ALPHA_GOTTPREL16
2128 ENUMX
2129   BFD_RELOC_ALPHA_TPREL64
2130 ENUMX
2131   BFD_RELOC_ALPHA_TPREL_HI16
2132 ENUMX
2133   BFD_RELOC_ALPHA_TPREL_LO16
2134 ENUMX
2135   BFD_RELOC_ALPHA_TPREL16
2136 ENUMDOC
2137   Alpha thread-local storage relocations.
2138
2139 ENUM
2140   BFD_RELOC_MIPS_JMP
2141 ENUMX
2142   BFD_RELOC_MICROMIPS_JMP
2143 ENUMDOC
2144   The MIPS jump instruction.
2145
2146 ENUM
2147   BFD_RELOC_MIPS16_JMP
2148 ENUMDOC
2149   The MIPS16 jump instruction.
2150
2151 ENUM
2152   BFD_RELOC_MIPS16_GPREL
2153 ENUMDOC
2154   MIPS16 GP relative reloc.
2155
2156 ENUM
2157   BFD_RELOC_HI16
2158 ENUMDOC
2159   High 16 bits of 32-bit value; simple reloc.
2160
2161 ENUM
2162   BFD_RELOC_HI16_S
2163 ENUMDOC
2164   High 16 bits of 32-bit value but the low 16 bits will be sign
2165      extended and added to form the final result.  If the low 16
2166      bits form a negative number, we need to add one to the high value
2167      to compensate for the borrow when the low bits are added.
2168
2169 ENUM
2170   BFD_RELOC_LO16
2171 ENUMDOC
2172   Low 16 bits.
2173
2174 ENUM
2175   BFD_RELOC_HI16_PCREL
2176 ENUMDOC
2177   High 16 bits of 32-bit pc-relative value
2178 ENUM
2179   BFD_RELOC_HI16_S_PCREL
2180 ENUMDOC
2181   High 16 bits of 32-bit pc-relative value, adjusted
2182 ENUM
2183   BFD_RELOC_LO16_PCREL
2184 ENUMDOC
2185   Low 16 bits of pc-relative value
2186
2187 ENUM
2188   BFD_RELOC_MIPS16_GOT16
2189 ENUMX
2190   BFD_RELOC_MIPS16_CALL16
2191 ENUMDOC
2192   Equivalent of BFD_RELOC_MIPS_*, but with the MIPS16 layout of
2193      16-bit immediate fields
2194 ENUM
2195   BFD_RELOC_MIPS16_HI16
2196 ENUMDOC
2197   MIPS16 high 16 bits of 32-bit value.
2198 ENUM
2199   BFD_RELOC_MIPS16_HI16_S
2200 ENUMDOC
2201   MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign
2202      extended and added to form the final result.  If the low 16
2203      bits form a negative number, we need to add one to the high value
2204      to compensate for the borrow when the low bits are added.
2205 ENUM
2206   BFD_RELOC_MIPS16_LO16
2207 ENUMDOC
2208   MIPS16 low 16 bits.
2209
2210 ENUM
2211   BFD_RELOC_MIPS16_TLS_GD
2212 ENUMX
2213   BFD_RELOC_MIPS16_TLS_LDM
2214 ENUMX
2215   BFD_RELOC_MIPS16_TLS_DTPREL_HI16
2216 ENUMX
2217   BFD_RELOC_MIPS16_TLS_DTPREL_LO16
2218 ENUMX
2219   BFD_RELOC_MIPS16_TLS_GOTTPREL
2220 ENUMX
2221   BFD_RELOC_MIPS16_TLS_TPREL_HI16
2222 ENUMX
2223   BFD_RELOC_MIPS16_TLS_TPREL_LO16
2224 ENUMDOC
2225   MIPS16 TLS relocations
2226
2227 ENUM
2228   BFD_RELOC_MIPS_LITERAL
2229 ENUMX
2230   BFD_RELOC_MICROMIPS_LITERAL
2231 ENUMDOC
2232   Relocation against a MIPS literal section.
2233
2234 ENUM
2235   BFD_RELOC_MICROMIPS_7_PCREL_S1
2236 ENUMX
2237   BFD_RELOC_MICROMIPS_10_PCREL_S1
2238 ENUMX
2239   BFD_RELOC_MICROMIPS_16_PCREL_S1
2240 ENUMDOC
2241   microMIPS PC-relative relocations.
2242
2243 ENUM
2244   BFD_RELOC_MIPS16_16_PCREL_S1
2245 ENUMDOC
2246   MIPS16 PC-relative relocation.
2247
2248 ENUM
2249   BFD_RELOC_MIPS_21_PCREL_S2
2250 ENUMX
2251   BFD_RELOC_MIPS_26_PCREL_S2
2252 ENUMX
2253   BFD_RELOC_MIPS_18_PCREL_S3
2254 ENUMX
2255   BFD_RELOC_MIPS_19_PCREL_S2
2256 ENUMDOC
2257   MIPS PC-relative relocations.
2258
2259 ENUM
2260   BFD_RELOC_MICROMIPS_GPREL16
2261 ENUMX
2262   BFD_RELOC_MICROMIPS_HI16
2263 ENUMX
2264   BFD_RELOC_MICROMIPS_HI16_S
2265 ENUMX
2266   BFD_RELOC_MICROMIPS_LO16
2267 ENUMDOC
2268   microMIPS versions of generic BFD relocs.
2269
2270 ENUM
2271   BFD_RELOC_MIPS_GOT16
2272 ENUMX
2273   BFD_RELOC_MICROMIPS_GOT16
2274 ENUMX
2275   BFD_RELOC_MIPS_CALL16
2276 ENUMX
2277   BFD_RELOC_MICROMIPS_CALL16
2278 ENUMX
2279   BFD_RELOC_MIPS_GOT_HI16
2280 ENUMX
2281   BFD_RELOC_MICROMIPS_GOT_HI16
2282 ENUMX
2283   BFD_RELOC_MIPS_GOT_LO16
2284 ENUMX
2285   BFD_RELOC_MICROMIPS_GOT_LO16
2286 ENUMX
2287   BFD_RELOC_MIPS_CALL_HI16
2288 ENUMX
2289   BFD_RELOC_MICROMIPS_CALL_HI16
2290 ENUMX
2291   BFD_RELOC_MIPS_CALL_LO16
2292 ENUMX
2293   BFD_RELOC_MICROMIPS_CALL_LO16
2294 ENUMX
2295   BFD_RELOC_MIPS_SUB
2296 ENUMX
2297   BFD_RELOC_MICROMIPS_SUB
2298 ENUMX
2299   BFD_RELOC_MIPS_GOT_PAGE
2300 ENUMX
2301   BFD_RELOC_MICROMIPS_GOT_PAGE
2302 ENUMX
2303   BFD_RELOC_MIPS_GOT_OFST
2304 ENUMX
2305   BFD_RELOC_MICROMIPS_GOT_OFST
2306 ENUMX
2307   BFD_RELOC_MIPS_GOT_DISP
2308 ENUMX
2309   BFD_RELOC_MICROMIPS_GOT_DISP
2310 ENUMX
2311   BFD_RELOC_MIPS_SHIFT5
2312 ENUMX
2313   BFD_RELOC_MIPS_SHIFT6
2314 ENUMX
2315   BFD_RELOC_MIPS_INSERT_A
2316 ENUMX
2317   BFD_RELOC_MIPS_INSERT_B
2318 ENUMX
2319   BFD_RELOC_MIPS_DELETE
2320 ENUMX
2321   BFD_RELOC_MIPS_HIGHEST
2322 ENUMX
2323   BFD_RELOC_MICROMIPS_HIGHEST
2324 ENUMX
2325   BFD_RELOC_MIPS_HIGHER
2326 ENUMX
2327   BFD_RELOC_MICROMIPS_HIGHER
2328 ENUMX
2329   BFD_RELOC_MIPS_SCN_DISP
2330 ENUMX
2331   BFD_RELOC_MICROMIPS_SCN_DISP
2332 ENUMX
2333   BFD_RELOC_MIPS_REL16
2334 ENUMX
2335   BFD_RELOC_MIPS_RELGOT
2336 ENUMX
2337   BFD_RELOC_MIPS_JALR
2338 ENUMX
2339   BFD_RELOC_MICROMIPS_JALR
2340 ENUMX
2341   BFD_RELOC_MIPS_TLS_DTPMOD32
2342 ENUMX
2343   BFD_RELOC_MIPS_TLS_DTPREL32
2344 ENUMX
2345   BFD_RELOC_MIPS_TLS_DTPMOD64
2346 ENUMX
2347   BFD_RELOC_MIPS_TLS_DTPREL64
2348 ENUMX
2349   BFD_RELOC_MIPS_TLS_GD
2350 ENUMX
2351   BFD_RELOC_MICROMIPS_TLS_GD
2352 ENUMX
2353   BFD_RELOC_MIPS_TLS_LDM
2354 ENUMX
2355   BFD_RELOC_MICROMIPS_TLS_LDM
2356 ENUMX
2357   BFD_RELOC_MIPS_TLS_DTPREL_HI16
2358 ENUMX
2359   BFD_RELOC_MICROMIPS_TLS_DTPREL_HI16
2360 ENUMX
2361   BFD_RELOC_MIPS_TLS_DTPREL_LO16
2362 ENUMX
2363   BFD_RELOC_MICROMIPS_TLS_DTPREL_LO16
2364 ENUMX
2365   BFD_RELOC_MIPS_TLS_GOTTPREL
2366 ENUMX
2367   BFD_RELOC_MICROMIPS_TLS_GOTTPREL
2368 ENUMX
2369   BFD_RELOC_MIPS_TLS_TPREL32
2370 ENUMX
2371   BFD_RELOC_MIPS_TLS_TPREL64
2372 ENUMX
2373   BFD_RELOC_MIPS_TLS_TPREL_HI16
2374 ENUMX
2375   BFD_RELOC_MICROMIPS_TLS_TPREL_HI16
2376 ENUMX
2377   BFD_RELOC_MIPS_TLS_TPREL_LO16
2378 ENUMX
2379   BFD_RELOC_MICROMIPS_TLS_TPREL_LO16
2380 ENUMX
2381   BFD_RELOC_MIPS_EH
2382 ENUMDOC
2383   MIPS ELF relocations.
2384 COMMENT
2385
2386 ENUM
2387   BFD_RELOC_MIPS_COPY
2388 ENUMX
2389   BFD_RELOC_MIPS_JUMP_SLOT
2390 ENUMDOC
2391   MIPS ELF relocations (VxWorks and PLT extensions).
2392 COMMENT
2393
2394 ENUM
2395   BFD_RELOC_MOXIE_10_PCREL
2396 ENUMDOC
2397   Moxie ELF relocations.
2398 COMMENT
2399
2400 ENUM
2401   BFD_RELOC_FT32_10
2402 ENUMX
2403   BFD_RELOC_FT32_20
2404 ENUMX
2405   BFD_RELOC_FT32_17
2406 ENUMX
2407   BFD_RELOC_FT32_18
2408 ENUMX
2409   BFD_RELOC_FT32_RELAX
2410 ENUMX
2411   BFD_RELOC_FT32_SC0
2412 ENUMX
2413   BFD_RELOC_FT32_SC1
2414 ENUMX
2415   BFD_RELOC_FT32_15
2416 ENUMX
2417   BFD_RELOC_FT32_DIFF32
2418 ENUMDOC
2419   FT32 ELF relocations.
2420 COMMENT
2421
2422 ENUM
2423   BFD_RELOC_FRV_LABEL16
2424 ENUMX
2425   BFD_RELOC_FRV_LABEL24
2426 ENUMX
2427   BFD_RELOC_FRV_LO16
2428 ENUMX
2429   BFD_RELOC_FRV_HI16
2430 ENUMX
2431   BFD_RELOC_FRV_GPREL12
2432 ENUMX
2433   BFD_RELOC_FRV_GPRELU12
2434 ENUMX
2435   BFD_RELOC_FRV_GPREL32
2436 ENUMX
2437   BFD_RELOC_FRV_GPRELHI
2438 ENUMX
2439   BFD_RELOC_FRV_GPRELLO
2440 ENUMX
2441   BFD_RELOC_FRV_GOT12
2442 ENUMX
2443   BFD_RELOC_FRV_GOTHI
2444 ENUMX
2445   BFD_RELOC_FRV_GOTLO
2446 ENUMX
2447   BFD_RELOC_FRV_FUNCDESC
2448 ENUMX
2449   BFD_RELOC_FRV_FUNCDESC_GOT12
2450 ENUMX
2451   BFD_RELOC_FRV_FUNCDESC_GOTHI
2452 ENUMX
2453   BFD_RELOC_FRV_FUNCDESC_GOTLO
2454 ENUMX
2455   BFD_RELOC_FRV_FUNCDESC_VALUE
2456 ENUMX
2457   BFD_RELOC_FRV_FUNCDESC_GOTOFF12
2458 ENUMX
2459   BFD_RELOC_FRV_FUNCDESC_GOTOFFHI
2460 ENUMX
2461   BFD_RELOC_FRV_FUNCDESC_GOTOFFLO
2462 ENUMX
2463   BFD_RELOC_FRV_GOTOFF12
2464 ENUMX
2465   BFD_RELOC_FRV_GOTOFFHI
2466 ENUMX
2467   BFD_RELOC_FRV_GOTOFFLO
2468 ENUMX
2469   BFD_RELOC_FRV_GETTLSOFF
2470 ENUMX
2471   BFD_RELOC_FRV_TLSDESC_VALUE
2472 ENUMX
2473   BFD_RELOC_FRV_GOTTLSDESC12
2474 ENUMX
2475   BFD_RELOC_FRV_GOTTLSDESCHI
2476 ENUMX
2477   BFD_RELOC_FRV_GOTTLSDESCLO
2478 ENUMX
2479   BFD_RELOC_FRV_TLSMOFF12
2480 ENUMX
2481   BFD_RELOC_FRV_TLSMOFFHI
2482 ENUMX
2483   BFD_RELOC_FRV_TLSMOFFLO
2484 ENUMX
2485   BFD_RELOC_FRV_GOTTLSOFF12
2486 ENUMX
2487   BFD_RELOC_FRV_GOTTLSOFFHI
2488 ENUMX
2489   BFD_RELOC_FRV_GOTTLSOFFLO
2490 ENUMX
2491   BFD_RELOC_FRV_TLSOFF
2492 ENUMX
2493   BFD_RELOC_FRV_TLSDESC_RELAX
2494 ENUMX
2495   BFD_RELOC_FRV_GETTLSOFF_RELAX
2496 ENUMX
2497   BFD_RELOC_FRV_TLSOFF_RELAX
2498 ENUMX
2499   BFD_RELOC_FRV_TLSMOFF
2500 ENUMDOC
2501   Fujitsu Frv Relocations.
2502 COMMENT
2503
2504 ENUM
2505   BFD_RELOC_MN10300_GOTOFF24
2506 ENUMDOC
2507   This is a 24bit GOT-relative reloc for the mn10300.
2508 ENUM
2509   BFD_RELOC_MN10300_GOT32
2510 ENUMDOC
2511   This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes
2512   in the instruction.
2513 ENUM
2514   BFD_RELOC_MN10300_GOT24
2515 ENUMDOC
2516   This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes
2517   in the instruction.
2518 ENUM
2519   BFD_RELOC_MN10300_GOT16
2520 ENUMDOC
2521   This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes
2522   in the instruction.
2523 ENUM
2524   BFD_RELOC_MN10300_COPY
2525 ENUMDOC
2526   Copy symbol at runtime.
2527 ENUM
2528   BFD_RELOC_MN10300_GLOB_DAT
2529 ENUMDOC
2530   Create GOT entry.
2531 ENUM
2532   BFD_RELOC_MN10300_JMP_SLOT
2533 ENUMDOC
2534   Create PLT entry.
2535 ENUM
2536   BFD_RELOC_MN10300_RELATIVE
2537 ENUMDOC
2538   Adjust by program base.
2539 ENUM
2540   BFD_RELOC_MN10300_SYM_DIFF
2541 ENUMDOC
2542   Together with another reloc targeted at the same location,
2543   allows for a value that is the difference of two symbols
2544   in the same section.
2545 ENUM
2546   BFD_RELOC_MN10300_ALIGN
2547 ENUMDOC
2548   The addend of this reloc is an alignment power that must
2549   be honoured at the offset's location, regardless of linker
2550   relaxation.
2551 ENUM
2552   BFD_RELOC_MN10300_TLS_GD
2553 ENUMX
2554   BFD_RELOC_MN10300_TLS_LD
2555 ENUMX
2556   BFD_RELOC_MN10300_TLS_LDO
2557 ENUMX
2558   BFD_RELOC_MN10300_TLS_GOTIE
2559 ENUMX
2560   BFD_RELOC_MN10300_TLS_IE
2561 ENUMX
2562   BFD_RELOC_MN10300_TLS_LE
2563 ENUMX
2564   BFD_RELOC_MN10300_TLS_DTPMOD
2565 ENUMX
2566   BFD_RELOC_MN10300_TLS_DTPOFF
2567 ENUMX
2568   BFD_RELOC_MN10300_TLS_TPOFF
2569 ENUMDOC
2570   Various TLS-related relocations.
2571 ENUM
2572   BFD_RELOC_MN10300_32_PCREL
2573 ENUMDOC
2574   This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2575   instruction.
2576 ENUM
2577   BFD_RELOC_MN10300_16_PCREL
2578 ENUMDOC
2579   This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2580   instruction.
2581 COMMENT
2582
2583 ENUM
2584   BFD_RELOC_386_GOT32
2585 ENUMX
2586   BFD_RELOC_386_PLT32
2587 ENUMX
2588   BFD_RELOC_386_COPY
2589 ENUMX
2590   BFD_RELOC_386_GLOB_DAT
2591 ENUMX
2592   BFD_RELOC_386_JUMP_SLOT
2593 ENUMX
2594   BFD_RELOC_386_RELATIVE
2595 ENUMX
2596   BFD_RELOC_386_GOTOFF
2597 ENUMX
2598   BFD_RELOC_386_GOTPC
2599 ENUMX
2600   BFD_RELOC_386_TLS_TPOFF
2601 ENUMX
2602   BFD_RELOC_386_TLS_IE
2603 ENUMX
2604   BFD_RELOC_386_TLS_GOTIE
2605 ENUMX
2606   BFD_RELOC_386_TLS_LE
2607 ENUMX
2608   BFD_RELOC_386_TLS_GD
2609 ENUMX
2610   BFD_RELOC_386_TLS_LDM
2611 ENUMX
2612   BFD_RELOC_386_TLS_LDO_32
2613 ENUMX
2614   BFD_RELOC_386_TLS_IE_32
2615 ENUMX
2616   BFD_RELOC_386_TLS_LE_32
2617 ENUMX
2618   BFD_RELOC_386_TLS_DTPMOD32
2619 ENUMX
2620   BFD_RELOC_386_TLS_DTPOFF32
2621 ENUMX
2622   BFD_RELOC_386_TLS_TPOFF32
2623 ENUMX
2624   BFD_RELOC_386_TLS_GOTDESC
2625 ENUMX
2626   BFD_RELOC_386_TLS_DESC_CALL
2627 ENUMX
2628   BFD_RELOC_386_TLS_DESC
2629 ENUMX
2630   BFD_RELOC_386_IRELATIVE
2631 ENUMX
2632   BFD_RELOC_386_GOT32X
2633 ENUMDOC
2634   i386/elf relocations
2635
2636 ENUM
2637   BFD_RELOC_X86_64_GOT32
2638 ENUMX
2639   BFD_RELOC_X86_64_PLT32
2640 ENUMX
2641   BFD_RELOC_X86_64_COPY
2642 ENUMX
2643   BFD_RELOC_X86_64_GLOB_DAT
2644 ENUMX
2645   BFD_RELOC_X86_64_JUMP_SLOT
2646 ENUMX
2647   BFD_RELOC_X86_64_RELATIVE
2648 ENUMX
2649   BFD_RELOC_X86_64_GOTPCREL
2650 ENUMX
2651   BFD_RELOC_X86_64_32S
2652 ENUMX
2653   BFD_RELOC_X86_64_DTPMOD64
2654 ENUMX
2655   BFD_RELOC_X86_64_DTPOFF64
2656 ENUMX
2657   BFD_RELOC_X86_64_TPOFF64
2658 ENUMX
2659   BFD_RELOC_X86_64_TLSGD
2660 ENUMX
2661   BFD_RELOC_X86_64_TLSLD
2662 ENUMX
2663   BFD_RELOC_X86_64_DTPOFF32
2664 ENUMX
2665   BFD_RELOC_X86_64_GOTTPOFF
2666 ENUMX
2667   BFD_RELOC_X86_64_TPOFF32
2668 ENUMX
2669   BFD_RELOC_X86_64_GOTOFF64
2670 ENUMX
2671   BFD_RELOC_X86_64_GOTPC32
2672 ENUMX
2673   BFD_RELOC_X86_64_GOT64
2674 ENUMX
2675   BFD_RELOC_X86_64_GOTPCREL64
2676 ENUMX
2677   BFD_RELOC_X86_64_GOTPC64
2678 ENUMX
2679   BFD_RELOC_X86_64_GOTPLT64
2680 ENUMX
2681   BFD_RELOC_X86_64_PLTOFF64
2682 ENUMX
2683   BFD_RELOC_X86_64_GOTPC32_TLSDESC
2684 ENUMX
2685   BFD_RELOC_X86_64_TLSDESC_CALL
2686 ENUMX
2687   BFD_RELOC_X86_64_TLSDESC
2688 ENUMX
2689   BFD_RELOC_X86_64_IRELATIVE
2690 ENUMX
2691   BFD_RELOC_X86_64_PC32_BND
2692 ENUMX
2693   BFD_RELOC_X86_64_PLT32_BND
2694 ENUMX
2695   BFD_RELOC_X86_64_GOTPCRELX
2696 ENUMX
2697   BFD_RELOC_X86_64_REX_GOTPCRELX
2698 ENUMDOC
2699   x86-64/elf relocations
2700
2701 ENUM
2702   BFD_RELOC_NS32K_IMM_8
2703 ENUMX
2704   BFD_RELOC_NS32K_IMM_16
2705 ENUMX
2706   BFD_RELOC_NS32K_IMM_32
2707 ENUMX
2708   BFD_RELOC_NS32K_IMM_8_PCREL
2709 ENUMX
2710   BFD_RELOC_NS32K_IMM_16_PCREL
2711 ENUMX
2712   BFD_RELOC_NS32K_IMM_32_PCREL
2713 ENUMX
2714   BFD_RELOC_NS32K_DISP_8
2715 ENUMX
2716   BFD_RELOC_NS32K_DISP_16
2717 ENUMX
2718   BFD_RELOC_NS32K_DISP_32
2719 ENUMX
2720   BFD_RELOC_NS32K_DISP_8_PCREL
2721 ENUMX
2722   BFD_RELOC_NS32K_DISP_16_PCREL
2723 ENUMX
2724   BFD_RELOC_NS32K_DISP_32_PCREL
2725 ENUMDOC
2726   ns32k relocations
2727
2728 ENUM
2729   BFD_RELOC_PDP11_DISP_8_PCREL
2730 ENUMX
2731   BFD_RELOC_PDP11_DISP_6_PCREL
2732 ENUMDOC
2733   PDP11 relocations
2734
2735 ENUM
2736   BFD_RELOC_PJ_CODE_HI16
2737 ENUMX
2738   BFD_RELOC_PJ_CODE_LO16
2739 ENUMX
2740   BFD_RELOC_PJ_CODE_DIR16
2741 ENUMX
2742   BFD_RELOC_PJ_CODE_DIR32
2743 ENUMX
2744   BFD_RELOC_PJ_CODE_REL16
2745 ENUMX
2746   BFD_RELOC_PJ_CODE_REL32
2747 ENUMDOC
2748   Picojava relocs.  Not all of these appear in object files.
2749
2750 ENUM
2751   BFD_RELOC_PPC_B26
2752 ENUMX
2753   BFD_RELOC_PPC_BA26
2754 ENUMX
2755   BFD_RELOC_PPC_TOC16
2756 ENUMX
2757   BFD_RELOC_PPC_B16
2758 ENUMX
2759   BFD_RELOC_PPC_B16_BRTAKEN
2760 ENUMX
2761   BFD_RELOC_PPC_B16_BRNTAKEN
2762 ENUMX
2763   BFD_RELOC_PPC_BA16
2764 ENUMX
2765   BFD_RELOC_PPC_BA16_BRTAKEN
2766 ENUMX
2767   BFD_RELOC_PPC_BA16_BRNTAKEN
2768 ENUMX
2769   BFD_RELOC_PPC_COPY
2770 ENUMX
2771   BFD_RELOC_PPC_GLOB_DAT
2772 ENUMX
2773   BFD_RELOC_PPC_JMP_SLOT
2774 ENUMX
2775   BFD_RELOC_PPC_RELATIVE
2776 ENUMX
2777   BFD_RELOC_PPC_LOCAL24PC
2778 ENUMX
2779   BFD_RELOC_PPC_EMB_NADDR32
2780 ENUMX
2781   BFD_RELOC_PPC_EMB_NADDR16
2782 ENUMX
2783   BFD_RELOC_PPC_EMB_NADDR16_LO
2784 ENUMX
2785   BFD_RELOC_PPC_EMB_NADDR16_HI
2786 ENUMX
2787   BFD_RELOC_PPC_EMB_NADDR16_HA
2788 ENUMX
2789   BFD_RELOC_PPC_EMB_SDAI16
2790 ENUMX
2791   BFD_RELOC_PPC_EMB_SDA2I16
2792 ENUMX
2793   BFD_RELOC_PPC_EMB_SDA2REL
2794 ENUMX
2795   BFD_RELOC_PPC_EMB_SDA21
2796 ENUMX
2797   BFD_RELOC_PPC_EMB_MRKREF
2798 ENUMX
2799   BFD_RELOC_PPC_EMB_RELSEC16
2800 ENUMX
2801   BFD_RELOC_PPC_EMB_RELST_LO
2802 ENUMX
2803   BFD_RELOC_PPC_EMB_RELST_HI
2804 ENUMX
2805   BFD_RELOC_PPC_EMB_RELST_HA
2806 ENUMX
2807   BFD_RELOC_PPC_EMB_BIT_FLD
2808 ENUMX
2809   BFD_RELOC_PPC_EMB_RELSDA
2810 ENUMX
2811   BFD_RELOC_PPC_VLE_REL8
2812 ENUMX
2813   BFD_RELOC_PPC_VLE_REL15
2814 ENUMX
2815   BFD_RELOC_PPC_VLE_REL24
2816 ENUMX
2817   BFD_RELOC_PPC_VLE_LO16A
2818 ENUMX
2819   BFD_RELOC_PPC_VLE_LO16D
2820 ENUMX
2821   BFD_RELOC_PPC_VLE_HI16A
2822 ENUMX
2823   BFD_RELOC_PPC_VLE_HI16D
2824 ENUMX
2825   BFD_RELOC_PPC_VLE_HA16A
2826 ENUMX
2827   BFD_RELOC_PPC_VLE_HA16D
2828 ENUMX
2829   BFD_RELOC_PPC_VLE_SDA21
2830 ENUMX
2831   BFD_RELOC_PPC_VLE_SDA21_LO
2832 ENUMX
2833   BFD_RELOC_PPC_VLE_SDAREL_LO16A
2834 ENUMX
2835   BFD_RELOC_PPC_VLE_SDAREL_LO16D
2836 ENUMX
2837   BFD_RELOC_PPC_VLE_SDAREL_HI16A
2838 ENUMX
2839   BFD_RELOC_PPC_VLE_SDAREL_HI16D
2840 ENUMX
2841   BFD_RELOC_PPC_VLE_SDAREL_HA16A
2842 ENUMX
2843   BFD_RELOC_PPC_VLE_SDAREL_HA16D
2844 ENUMX
2845   BFD_RELOC_PPC_16DX_HA
2846 ENUMX
2847   BFD_RELOC_PPC_REL16DX_HA
2848 ENUMX
2849   BFD_RELOC_PPC64_HIGHER
2850 ENUMX
2851   BFD_RELOC_PPC64_HIGHER_S
2852 ENUMX
2853   BFD_RELOC_PPC64_HIGHEST
2854 ENUMX
2855   BFD_RELOC_PPC64_HIGHEST_S
2856 ENUMX
2857   BFD_RELOC_PPC64_TOC16_LO
2858 ENUMX
2859   BFD_RELOC_PPC64_TOC16_HI
2860 ENUMX
2861   BFD_RELOC_PPC64_TOC16_HA
2862 ENUMX
2863   BFD_RELOC_PPC64_TOC
2864 ENUMX
2865   BFD_RELOC_PPC64_PLTGOT16
2866 ENUMX
2867   BFD_RELOC_PPC64_PLTGOT16_LO
2868 ENUMX
2869   BFD_RELOC_PPC64_PLTGOT16_HI
2870 ENUMX
2871   BFD_RELOC_PPC64_PLTGOT16_HA
2872 ENUMX
2873   BFD_RELOC_PPC64_ADDR16_DS
2874 ENUMX
2875   BFD_RELOC_PPC64_ADDR16_LO_DS
2876 ENUMX
2877   BFD_RELOC_PPC64_GOT16_DS
2878 ENUMX
2879   BFD_RELOC_PPC64_GOT16_LO_DS
2880 ENUMX
2881   BFD_RELOC_PPC64_PLT16_LO_DS
2882 ENUMX
2883   BFD_RELOC_PPC64_SECTOFF_DS
2884 ENUMX
2885   BFD_RELOC_PPC64_SECTOFF_LO_DS
2886 ENUMX
2887   BFD_RELOC_PPC64_TOC16_DS
2888 ENUMX
2889   BFD_RELOC_PPC64_TOC16_LO_DS
2890 ENUMX
2891   BFD_RELOC_PPC64_PLTGOT16_DS
2892 ENUMX
2893   BFD_RELOC_PPC64_PLTGOT16_LO_DS
2894 ENUMX
2895   BFD_RELOC_PPC64_ADDR16_HIGH
2896 ENUMX
2897   BFD_RELOC_PPC64_ADDR16_HIGHA
2898 ENUMX
2899   BFD_RELOC_PPC64_REL16_HIGH
2900 ENUMX
2901   BFD_RELOC_PPC64_REL16_HIGHA
2902 ENUMX
2903   BFD_RELOC_PPC64_REL16_HIGHER
2904 ENUMX
2905   BFD_RELOC_PPC64_REL16_HIGHERA
2906 ENUMX
2907   BFD_RELOC_PPC64_REL16_HIGHEST
2908 ENUMX
2909   BFD_RELOC_PPC64_REL16_HIGHESTA
2910 ENUMX
2911   BFD_RELOC_PPC64_ADDR64_LOCAL
2912 ENUMX
2913   BFD_RELOC_PPC64_ENTRY
2914 ENUMX
2915   BFD_RELOC_PPC64_REL24_NOTOC
2916 ENUMX
2917   BFD_RELOC_PPC64_D34
2918 ENUMX
2919   BFD_RELOC_PPC64_D34_LO
2920 ENUMX
2921   BFD_RELOC_PPC64_D34_HI30
2922 ENUMX
2923   BFD_RELOC_PPC64_D34_HA30
2924 ENUMX
2925   BFD_RELOC_PPC64_PCREL34
2926 ENUMX
2927   BFD_RELOC_PPC64_GOT_PCREL34
2928 ENUMX
2929   BFD_RELOC_PPC64_PLT_PCREL34
2930 ENUMX
2931   BFD_RELOC_PPC64_ADDR16_HIGHER34
2932 ENUMX
2933   BFD_RELOC_PPC64_ADDR16_HIGHERA34
2934 ENUMX
2935   BFD_RELOC_PPC64_ADDR16_HIGHEST34
2936 ENUMX
2937   BFD_RELOC_PPC64_ADDR16_HIGHESTA34
2938 ENUMX
2939   BFD_RELOC_PPC64_REL16_HIGHER34
2940 ENUMX
2941   BFD_RELOC_PPC64_REL16_HIGHERA34
2942 ENUMX
2943   BFD_RELOC_PPC64_REL16_HIGHEST34
2944 ENUMX
2945   BFD_RELOC_PPC64_REL16_HIGHESTA34
2946 ENUMX
2947   BFD_RELOC_PPC64_D28
2948 ENUMX
2949   BFD_RELOC_PPC64_PCREL28
2950 ENUMDOC
2951   Power(rs6000) and PowerPC relocations.
2952
2953 ENUM
2954   BFD_RELOC_PPC_TLS
2955 ENUMX
2956   BFD_RELOC_PPC_TLSGD
2957 ENUMX
2958   BFD_RELOC_PPC_TLSLD
2959 ENUMX
2960   BFD_RELOC_PPC_DTPMOD
2961 ENUMX
2962   BFD_RELOC_PPC_TPREL16
2963 ENUMX
2964   BFD_RELOC_PPC_TPREL16_LO
2965 ENUMX
2966   BFD_RELOC_PPC_TPREL16_HI
2967 ENUMX
2968   BFD_RELOC_PPC_TPREL16_HA
2969 ENUMX
2970   BFD_RELOC_PPC_TPREL
2971 ENUMX
2972   BFD_RELOC_PPC_DTPREL16
2973 ENUMX
2974   BFD_RELOC_PPC_DTPREL16_LO
2975 ENUMX
2976   BFD_RELOC_PPC_DTPREL16_HI
2977 ENUMX
2978   BFD_RELOC_PPC_DTPREL16_HA
2979 ENUMX
2980   BFD_RELOC_PPC_DTPREL
2981 ENUMX
2982   BFD_RELOC_PPC_GOT_TLSGD16
2983 ENUMX
2984   BFD_RELOC_PPC_GOT_TLSGD16_LO
2985 ENUMX
2986   BFD_RELOC_PPC_GOT_TLSGD16_HI
2987 ENUMX
2988   BFD_RELOC_PPC_GOT_TLSGD16_HA
2989 ENUMX
2990   BFD_RELOC_PPC_GOT_TLSLD16
2991 ENUMX
2992   BFD_RELOC_PPC_GOT_TLSLD16_LO
2993 ENUMX
2994   BFD_RELOC_PPC_GOT_TLSLD16_HI
2995 ENUMX
2996   BFD_RELOC_PPC_GOT_TLSLD16_HA
2997 ENUMX
2998   BFD_RELOC_PPC_GOT_TPREL16
2999 ENUMX
3000   BFD_RELOC_PPC_GOT_TPREL16_LO
3001 ENUMX
3002   BFD_RELOC_PPC_GOT_TPREL16_HI
3003 ENUMX
3004   BFD_RELOC_PPC_GOT_TPREL16_HA
3005 ENUMX
3006   BFD_RELOC_PPC_GOT_DTPREL16
3007 ENUMX
3008   BFD_RELOC_PPC_GOT_DTPREL16_LO
3009 ENUMX
3010   BFD_RELOC_PPC_GOT_DTPREL16_HI
3011 ENUMX
3012   BFD_RELOC_PPC_GOT_DTPREL16_HA
3013 ENUMX
3014   BFD_RELOC_PPC64_TPREL16_DS
3015 ENUMX
3016   BFD_RELOC_PPC64_TPREL16_LO_DS
3017 ENUMX
3018   BFD_RELOC_PPC64_TPREL16_HIGH
3019 ENUMX
3020   BFD_RELOC_PPC64_TPREL16_HIGHA
3021 ENUMX
3022   BFD_RELOC_PPC64_TPREL16_HIGHER
3023 ENUMX
3024   BFD_RELOC_PPC64_TPREL16_HIGHERA
3025 ENUMX
3026   BFD_RELOC_PPC64_TPREL16_HIGHEST
3027 ENUMX
3028   BFD_RELOC_PPC64_TPREL16_HIGHESTA
3029 ENUMX
3030   BFD_RELOC_PPC64_DTPREL16_DS
3031 ENUMX
3032   BFD_RELOC_PPC64_DTPREL16_LO_DS
3033 ENUMX
3034   BFD_RELOC_PPC64_DTPREL16_HIGH
3035 ENUMX
3036   BFD_RELOC_PPC64_DTPREL16_HIGHA
3037 ENUMX
3038   BFD_RELOC_PPC64_DTPREL16_HIGHER
3039 ENUMX
3040   BFD_RELOC_PPC64_DTPREL16_HIGHERA
3041 ENUMX
3042   BFD_RELOC_PPC64_DTPREL16_HIGHEST
3043 ENUMX
3044   BFD_RELOC_PPC64_DTPREL16_HIGHESTA
3045 ENUMX
3046   BFD_RELOC_PPC64_TPREL34
3047 ENUMX
3048   BFD_RELOC_PPC64_DTPREL34
3049 ENUMX
3050   BFD_RELOC_PPC64_GOT_TLSGD_PCREL34
3051 ENUMX
3052   BFD_RELOC_PPC64_GOT_TLSLD_PCREL34
3053 ENUMX
3054   BFD_RELOC_PPC64_GOT_TPREL_PCREL34
3055 ENUMX
3056   BFD_RELOC_PPC64_GOT_DTPREL_PCREL34
3057 ENUMX
3058   BFD_RELOC_PPC64_TLS_PCREL
3059 ENUMDOC
3060   PowerPC and PowerPC64 thread-local storage relocations.
3061
3062 ENUM
3063   BFD_RELOC_I370_D12
3064 ENUMDOC
3065   IBM 370/390 relocations
3066
3067 ENUM
3068   BFD_RELOC_CTOR
3069 ENUMDOC
3070   The type of reloc used to build a constructor table - at the moment
3071   probably a 32 bit wide absolute relocation, but the target can choose.
3072   It generally does map to one of the other relocation types.
3073
3074 ENUM
3075   BFD_RELOC_ARM_PCREL_BRANCH
3076 ENUMDOC
3077   ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
3078   not stored in the instruction.
3079 ENUM
3080   BFD_RELOC_ARM_PCREL_BLX
3081 ENUMDOC
3082   ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
3083   not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
3084   field in the instruction.
3085 ENUM
3086   BFD_RELOC_THUMB_PCREL_BLX
3087 ENUMDOC
3088   Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
3089   not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
3090   field in the instruction.
3091 ENUM
3092   BFD_RELOC_ARM_PCREL_CALL
3093 ENUMDOC
3094   ARM 26-bit pc-relative branch for an unconditional BL or BLX instruction.
3095 ENUM
3096   BFD_RELOC_ARM_PCREL_JUMP
3097 ENUMDOC
3098   ARM 26-bit pc-relative branch for B or conditional BL instruction.
3099
3100 ENUM
3101   BFD_RELOC_THUMB_PCREL_BRANCH5
3102 ENUMDOC
3103   ARM 5-bit pc-relative branch for Branch Future instructions.
3104
3105 ENUM
3106   BFD_RELOC_THUMB_PCREL_BFCSEL
3107 ENUMDOC
3108   ARM 6-bit pc-relative branch for BFCSEL instruction.
3109
3110 ENUM
3111   BFD_RELOC_ARM_THUMB_BF17
3112 ENUMDOC
3113   ARM 17-bit pc-relative branch for Branch Future instructions.
3114
3115 ENUM
3116   BFD_RELOC_ARM_THUMB_BF13
3117 ENUMDOC
3118   ARM 13-bit pc-relative branch for BFCSEL instruction.
3119
3120 ENUM
3121   BFD_RELOC_ARM_THUMB_BF19
3122 ENUMDOC
3123   ARM 19-bit pc-relative branch for Branch Future Link instruction.
3124
3125 ENUM
3126   BFD_RELOC_ARM_THUMB_LOOP12
3127 ENUMDOC
3128   ARM 12-bit pc-relative branch for Low Overhead Loop instructions.
3129
3130 ENUM
3131   BFD_RELOC_THUMB_PCREL_BRANCH7
3132 ENUMX
3133   BFD_RELOC_THUMB_PCREL_BRANCH9
3134 ENUMX
3135   BFD_RELOC_THUMB_PCREL_BRANCH12
3136 ENUMX
3137   BFD_RELOC_THUMB_PCREL_BRANCH20
3138 ENUMX
3139   BFD_RELOC_THUMB_PCREL_BRANCH23
3140 ENUMX
3141   BFD_RELOC_THUMB_PCREL_BRANCH25
3142 ENUMDOC
3143   Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches.
3144   The lowest bit must be zero and is not stored in the instruction.
3145   Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an
3146   "nn" one smaller in all cases.  Note further that BRANCH23
3147   corresponds to R_ARM_THM_CALL.
3148
3149 ENUM
3150   BFD_RELOC_ARM_OFFSET_IMM
3151 ENUMDOC
3152   12-bit immediate offset, used in ARM-format ldr and str instructions.
3153
3154 ENUM
3155   BFD_RELOC_ARM_THUMB_OFFSET
3156 ENUMDOC
3157   5-bit immediate offset, used in Thumb-format ldr and str instructions.
3158
3159 ENUM
3160   BFD_RELOC_ARM_TARGET1
3161 ENUMDOC
3162   Pc-relative or absolute relocation depending on target.  Used for
3163   entries in .init_array sections.
3164 ENUM
3165   BFD_RELOC_ARM_ROSEGREL32
3166 ENUMDOC
3167   Read-only segment base relative address.
3168 ENUM
3169   BFD_RELOC_ARM_SBREL32
3170 ENUMDOC
3171   Data segment base relative address.
3172 ENUM
3173   BFD_RELOC_ARM_TARGET2
3174 ENUMDOC
3175   This reloc is used for references to RTTI data from exception handling
3176   tables.  The actual definition depends on the target.  It may be a
3177   pc-relative or some form of GOT-indirect relocation.
3178 ENUM
3179   BFD_RELOC_ARM_PREL31
3180 ENUMDOC
3181   31-bit PC relative address.
3182 ENUM
3183   BFD_RELOC_ARM_MOVW
3184 ENUMX
3185   BFD_RELOC_ARM_MOVT
3186 ENUMX
3187   BFD_RELOC_ARM_MOVW_PCREL
3188 ENUMX
3189   BFD_RELOC_ARM_MOVT_PCREL
3190 ENUMX
3191   BFD_RELOC_ARM_THUMB_MOVW
3192 ENUMX
3193   BFD_RELOC_ARM_THUMB_MOVT
3194 ENUMX
3195   BFD_RELOC_ARM_THUMB_MOVW_PCREL
3196 ENUMX
3197   BFD_RELOC_ARM_THUMB_MOVT_PCREL
3198 ENUMDOC
3199   Low and High halfword relocations for MOVW and MOVT instructions.
3200
3201 ENUM
3202   BFD_RELOC_ARM_GOTFUNCDESC
3203 ENUMX
3204   BFD_RELOC_ARM_GOTOFFFUNCDESC
3205 ENUMX
3206   BFD_RELOC_ARM_FUNCDESC
3207 ENUMX
3208   BFD_RELOC_ARM_FUNCDESC_VALUE
3209 ENUMX
3210   BFD_RELOC_ARM_TLS_GD32_FDPIC
3211 ENUMX
3212   BFD_RELOC_ARM_TLS_LDM32_FDPIC
3213 ENUMX
3214   BFD_RELOC_ARM_TLS_IE32_FDPIC
3215 ENUMDOC
3216   ARM FDPIC specific relocations.
3217
3218 ENUM
3219   BFD_RELOC_ARM_JUMP_SLOT
3220 ENUMX
3221   BFD_RELOC_ARM_GLOB_DAT
3222 ENUMX
3223   BFD_RELOC_ARM_GOT32
3224 ENUMX
3225   BFD_RELOC_ARM_PLT32
3226 ENUMX
3227   BFD_RELOC_ARM_RELATIVE
3228 ENUMX
3229   BFD_RELOC_ARM_GOTOFF
3230 ENUMX
3231   BFD_RELOC_ARM_GOTPC
3232 ENUMX
3233   BFD_RELOC_ARM_GOT_PREL
3234 ENUMDOC
3235   Relocations for setting up GOTs and PLTs for shared libraries.
3236
3237 ENUM
3238   BFD_RELOC_ARM_TLS_GD32
3239 ENUMX
3240   BFD_RELOC_ARM_TLS_LDO32
3241 ENUMX
3242   BFD_RELOC_ARM_TLS_LDM32
3243 ENUMX
3244   BFD_RELOC_ARM_TLS_DTPOFF32
3245 ENUMX
3246   BFD_RELOC_ARM_TLS_DTPMOD32
3247 ENUMX
3248   BFD_RELOC_ARM_TLS_TPOFF32
3249 ENUMX
3250   BFD_RELOC_ARM_TLS_IE32
3251 ENUMX
3252   BFD_RELOC_ARM_TLS_LE32
3253 ENUMX
3254   BFD_RELOC_ARM_TLS_GOTDESC
3255 ENUMX
3256   BFD_RELOC_ARM_TLS_CALL
3257 ENUMX
3258   BFD_RELOC_ARM_THM_TLS_CALL
3259 ENUMX
3260   BFD_RELOC_ARM_TLS_DESCSEQ
3261 ENUMX
3262   BFD_RELOC_ARM_THM_TLS_DESCSEQ
3263 ENUMX
3264   BFD_RELOC_ARM_TLS_DESC
3265 ENUMDOC
3266   ARM thread-local storage relocations.
3267
3268 ENUM
3269   BFD_RELOC_ARM_ALU_PC_G0_NC
3270 ENUMX
3271   BFD_RELOC_ARM_ALU_PC_G0
3272 ENUMX
3273   BFD_RELOC_ARM_ALU_PC_G1_NC
3274 ENUMX
3275   BFD_RELOC_ARM_ALU_PC_G1
3276 ENUMX
3277   BFD_RELOC_ARM_ALU_PC_G2
3278 ENUMX
3279   BFD_RELOC_ARM_LDR_PC_G0
3280 ENUMX
3281   BFD_RELOC_ARM_LDR_PC_G1
3282 ENUMX
3283   BFD_RELOC_ARM_LDR_PC_G2
3284 ENUMX
3285   BFD_RELOC_ARM_LDRS_PC_G0
3286 ENUMX
3287   BFD_RELOC_ARM_LDRS_PC_G1
3288 ENUMX
3289   BFD_RELOC_ARM_LDRS_PC_G2
3290 ENUMX
3291   BFD_RELOC_ARM_LDC_PC_G0
3292 ENUMX
3293   BFD_RELOC_ARM_LDC_PC_G1
3294 ENUMX
3295   BFD_RELOC_ARM_LDC_PC_G2
3296 ENUMX
3297   BFD_RELOC_ARM_ALU_SB_G0_NC
3298 ENUMX
3299   BFD_RELOC_ARM_ALU_SB_G0
3300 ENUMX
3301   BFD_RELOC_ARM_ALU_SB_G1_NC
3302 ENUMX
3303   BFD_RELOC_ARM_ALU_SB_G1
3304 ENUMX
3305   BFD_RELOC_ARM_ALU_SB_G2
3306 ENUMX
3307   BFD_RELOC_ARM_LDR_SB_G0
3308 ENUMX
3309   BFD_RELOC_ARM_LDR_SB_G1
3310 ENUMX
3311   BFD_RELOC_ARM_LDR_SB_G2
3312 ENUMX
3313   BFD_RELOC_ARM_LDRS_SB_G0
3314 ENUMX
3315   BFD_RELOC_ARM_LDRS_SB_G1
3316 ENUMX
3317   BFD_RELOC_ARM_LDRS_SB_G2
3318 ENUMX
3319   BFD_RELOC_ARM_LDC_SB_G0
3320 ENUMX
3321   BFD_RELOC_ARM_LDC_SB_G1
3322 ENUMX
3323   BFD_RELOC_ARM_LDC_SB_G2
3324 ENUMDOC
3325   ARM group relocations.
3326
3327 ENUM
3328   BFD_RELOC_ARM_V4BX
3329 ENUMDOC
3330   Annotation of BX instructions.
3331
3332 ENUM
3333   BFD_RELOC_ARM_IRELATIVE
3334 ENUMDOC
3335   ARM support for STT_GNU_IFUNC.
3336
3337 ENUM
3338   BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC
3339 ENUMX
3340   BFD_RELOC_ARM_THUMB_ALU_ABS_G1_NC
3341 ENUMX
3342   BFD_RELOC_ARM_THUMB_ALU_ABS_G2_NC
3343 ENUMX
3344   BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC
3345 ENUMDOC
3346   Thumb1 relocations to support execute-only code.
3347
3348 ENUM
3349   BFD_RELOC_ARM_IMMEDIATE
3350 ENUMX
3351   BFD_RELOC_ARM_ADRL_IMMEDIATE
3352 ENUMX
3353   BFD_RELOC_ARM_T32_IMMEDIATE
3354 ENUMX
3355   BFD_RELOC_ARM_T32_ADD_IMM
3356 ENUMX
3357   BFD_RELOC_ARM_T32_IMM12
3358 ENUMX
3359   BFD_RELOC_ARM_T32_ADD_PC12
3360 ENUMX
3361   BFD_RELOC_ARM_SHIFT_IMM
3362 ENUMX
3363   BFD_RELOC_ARM_SMC
3364 ENUMX
3365   BFD_RELOC_ARM_HVC
3366 ENUMX
3367   BFD_RELOC_ARM_SWI
3368 ENUMX
3369   BFD_RELOC_ARM_MULTI
3370 ENUMX
3371   BFD_RELOC_ARM_CP_OFF_IMM
3372 ENUMX
3373   BFD_RELOC_ARM_CP_OFF_IMM_S2
3374 ENUMX
3375   BFD_RELOC_ARM_T32_CP_OFF_IMM
3376 ENUMX
3377   BFD_RELOC_ARM_T32_CP_OFF_IMM_S2
3378 ENUMX
3379   BFD_RELOC_ARM_T32_VLDR_VSTR_OFF_IMM
3380 ENUMX
3381   BFD_RELOC_ARM_ADR_IMM
3382 ENUMX
3383   BFD_RELOC_ARM_LDR_IMM
3384 ENUMX
3385   BFD_RELOC_ARM_LITERAL
3386 ENUMX
3387   BFD_RELOC_ARM_IN_POOL
3388 ENUMX
3389   BFD_RELOC_ARM_OFFSET_IMM8
3390 ENUMX
3391   BFD_RELOC_ARM_T32_OFFSET_U8
3392 ENUMX
3393   BFD_RELOC_ARM_T32_OFFSET_IMM
3394 ENUMX
3395   BFD_RELOC_ARM_HWLITERAL
3396 ENUMX
3397   BFD_RELOC_ARM_THUMB_ADD
3398 ENUMX
3399   BFD_RELOC_ARM_THUMB_IMM
3400 ENUMX
3401   BFD_RELOC_ARM_THUMB_SHIFT
3402 ENUMDOC
3403   These relocs are only used within the ARM assembler.  They are not
3404   (at present) written to any object files.
3405
3406 ENUM
3407   BFD_RELOC_SH_PCDISP8BY2
3408 ENUMX
3409   BFD_RELOC_SH_PCDISP12BY2
3410 ENUMX
3411   BFD_RELOC_SH_IMM3
3412 ENUMX
3413   BFD_RELOC_SH_IMM3U
3414 ENUMX
3415   BFD_RELOC_SH_DISP12
3416 ENUMX
3417   BFD_RELOC_SH_DISP12BY2
3418 ENUMX
3419   BFD_RELOC_SH_DISP12BY4
3420 ENUMX
3421   BFD_RELOC_SH_DISP12BY8
3422 ENUMX
3423   BFD_RELOC_SH_DISP20
3424 ENUMX
3425   BFD_RELOC_SH_DISP20BY8
3426 ENUMX
3427   BFD_RELOC_SH_IMM4
3428 ENUMX
3429   BFD_RELOC_SH_IMM4BY2
3430 ENUMX
3431   BFD_RELOC_SH_IMM4BY4
3432 ENUMX
3433   BFD_RELOC_SH_IMM8
3434 ENUMX
3435   BFD_RELOC_SH_IMM8BY2
3436 ENUMX
3437   BFD_RELOC_SH_IMM8BY4
3438 ENUMX
3439   BFD_RELOC_SH_PCRELIMM8BY2
3440 ENUMX
3441   BFD_RELOC_SH_PCRELIMM8BY4
3442 ENUMX
3443   BFD_RELOC_SH_SWITCH16
3444 ENUMX
3445   BFD_RELOC_SH_SWITCH32
3446 ENUMX
3447   BFD_RELOC_SH_USES
3448 ENUMX
3449   BFD_RELOC_SH_COUNT
3450 ENUMX
3451   BFD_RELOC_SH_ALIGN
3452 ENUMX
3453   BFD_RELOC_SH_CODE
3454 ENUMX
3455   BFD_RELOC_SH_DATA
3456 ENUMX
3457   BFD_RELOC_SH_LABEL
3458 ENUMX
3459   BFD_RELOC_SH_LOOP_START
3460 ENUMX
3461   BFD_RELOC_SH_LOOP_END
3462 ENUMX
3463   BFD_RELOC_SH_COPY
3464 ENUMX
3465   BFD_RELOC_SH_GLOB_DAT
3466 ENUMX
3467   BFD_RELOC_SH_JMP_SLOT
3468 ENUMX
3469   BFD_RELOC_SH_RELATIVE
3470 ENUMX
3471   BFD_RELOC_SH_GOTPC
3472 ENUMX
3473   BFD_RELOC_SH_GOT_LOW16
3474 ENUMX
3475   BFD_RELOC_SH_GOT_MEDLOW16
3476 ENUMX
3477   BFD_RELOC_SH_GOT_MEDHI16
3478 ENUMX
3479   BFD_RELOC_SH_GOT_HI16
3480 ENUMX
3481   BFD_RELOC_SH_GOTPLT_LOW16
3482 ENUMX
3483   BFD_RELOC_SH_GOTPLT_MEDLOW16
3484 ENUMX
3485   BFD_RELOC_SH_GOTPLT_MEDHI16
3486 ENUMX
3487   BFD_RELOC_SH_GOTPLT_HI16
3488 ENUMX
3489   BFD_RELOC_SH_PLT_LOW16
3490 ENUMX
3491   BFD_RELOC_SH_PLT_MEDLOW16
3492 ENUMX
3493   BFD_RELOC_SH_PLT_MEDHI16
3494 ENUMX
3495   BFD_RELOC_SH_PLT_HI16
3496 ENUMX
3497   BFD_RELOC_SH_GOTOFF_LOW16
3498 ENUMX
3499   BFD_RELOC_SH_GOTOFF_MEDLOW16
3500 ENUMX
3501   BFD_RELOC_SH_GOTOFF_MEDHI16
3502 ENUMX
3503   BFD_RELOC_SH_GOTOFF_HI16
3504 ENUMX
3505   BFD_RELOC_SH_GOTPC_LOW16
3506 ENUMX
3507   BFD_RELOC_SH_GOTPC_MEDLOW16
3508 ENUMX
3509   BFD_RELOC_SH_GOTPC_MEDHI16
3510 ENUMX
3511   BFD_RELOC_SH_GOTPC_HI16
3512 ENUMX
3513   BFD_RELOC_SH_COPY64
3514 ENUMX
3515   BFD_RELOC_SH_GLOB_DAT64
3516 ENUMX
3517   BFD_RELOC_SH_JMP_SLOT64
3518 ENUMX
3519   BFD_RELOC_SH_RELATIVE64
3520 ENUMX
3521   BFD_RELOC_SH_GOT10BY4
3522 ENUMX
3523   BFD_RELOC_SH_GOT10BY8
3524 ENUMX
3525   BFD_RELOC_SH_GOTPLT10BY4
3526 ENUMX
3527   BFD_RELOC_SH_GOTPLT10BY8
3528 ENUMX
3529   BFD_RELOC_SH_GOTPLT32
3530 ENUMX
3531   BFD_RELOC_SH_SHMEDIA_CODE
3532 ENUMX
3533   BFD_RELOC_SH_IMMU5
3534 ENUMX
3535   BFD_RELOC_SH_IMMS6
3536 ENUMX
3537   BFD_RELOC_SH_IMMS6BY32
3538 ENUMX
3539   BFD_RELOC_SH_IMMU6
3540 ENUMX
3541   BFD_RELOC_SH_IMMS10
3542 ENUMX
3543   BFD_RELOC_SH_IMMS10BY2
3544 ENUMX
3545   BFD_RELOC_SH_IMMS10BY4
3546 ENUMX
3547   BFD_RELOC_SH_IMMS10BY8
3548 ENUMX
3549   BFD_RELOC_SH_IMMS16
3550 ENUMX
3551   BFD_RELOC_SH_IMMU16
3552 ENUMX
3553   BFD_RELOC_SH_IMM_LOW16
3554 ENUMX
3555   BFD_RELOC_SH_IMM_LOW16_PCREL
3556 ENUMX
3557   BFD_RELOC_SH_IMM_MEDLOW16
3558 ENUMX
3559   BFD_RELOC_SH_IMM_MEDLOW16_PCREL
3560 ENUMX
3561   BFD_RELOC_SH_IMM_MEDHI16
3562 ENUMX
3563   BFD_RELOC_SH_IMM_MEDHI16_PCREL
3564 ENUMX
3565   BFD_RELOC_SH_IMM_HI16
3566 ENUMX
3567   BFD_RELOC_SH_IMM_HI16_PCREL
3568 ENUMX
3569   BFD_RELOC_SH_PT_16
3570 ENUMX
3571   BFD_RELOC_SH_TLS_GD_32
3572 ENUMX
3573   BFD_RELOC_SH_TLS_LD_32
3574 ENUMX
3575   BFD_RELOC_SH_TLS_LDO_32
3576 ENUMX
3577   BFD_RELOC_SH_TLS_IE_32
3578 ENUMX
3579   BFD_RELOC_SH_TLS_LE_32
3580 ENUMX
3581   BFD_RELOC_SH_TLS_DTPMOD32
3582 ENUMX
3583   BFD_RELOC_SH_TLS_DTPOFF32
3584 ENUMX
3585   BFD_RELOC_SH_TLS_TPOFF32
3586 ENUMX
3587   BFD_RELOC_SH_GOT20
3588 ENUMX
3589   BFD_RELOC_SH_GOTOFF20
3590 ENUMX
3591   BFD_RELOC_SH_GOTFUNCDESC
3592 ENUMX
3593   BFD_RELOC_SH_GOTFUNCDESC20
3594 ENUMX
3595   BFD_RELOC_SH_GOTOFFFUNCDESC
3596 ENUMX
3597   BFD_RELOC_SH_GOTOFFFUNCDESC20
3598 ENUMX
3599   BFD_RELOC_SH_FUNCDESC
3600 ENUMDOC
3601   Renesas / SuperH SH relocs.  Not all of these appear in object files.
3602
3603 ENUM
3604   BFD_RELOC_ARC_NONE
3605 ENUMX
3606   BFD_RELOC_ARC_8
3607 ENUMX
3608   BFD_RELOC_ARC_16
3609 ENUMX
3610   BFD_RELOC_ARC_24
3611 ENUMX
3612   BFD_RELOC_ARC_32
3613 ENUMX
3614   BFD_RELOC_ARC_N8
3615 ENUMX
3616   BFD_RELOC_ARC_N16
3617 ENUMX
3618   BFD_RELOC_ARC_N24
3619 ENUMX
3620   BFD_RELOC_ARC_N32
3621 ENUMX
3622   BFD_RELOC_ARC_SDA
3623 ENUMX
3624   BFD_RELOC_ARC_SECTOFF
3625 ENUMX
3626   BFD_RELOC_ARC_S21H_PCREL
3627 ENUMX
3628   BFD_RELOC_ARC_S21W_PCREL
3629 ENUMX
3630   BFD_RELOC_ARC_S25H_PCREL
3631 ENUMX
3632   BFD_RELOC_ARC_S25W_PCREL
3633 ENUMX
3634   BFD_RELOC_ARC_SDA32
3635 ENUMX
3636   BFD_RELOC_ARC_SDA_LDST
3637 ENUMX
3638   BFD_RELOC_ARC_SDA_LDST1
3639 ENUMX
3640   BFD_RELOC_ARC_SDA_LDST2
3641 ENUMX
3642   BFD_RELOC_ARC_SDA16_LD
3643 ENUMX
3644   BFD_RELOC_ARC_SDA16_LD1
3645 ENUMX
3646   BFD_RELOC_ARC_SDA16_LD2
3647 ENUMX
3648   BFD_RELOC_ARC_S13_PCREL
3649 ENUMX
3650   BFD_RELOC_ARC_W
3651 ENUMX
3652   BFD_RELOC_ARC_32_ME
3653 ENUMX
3654   BFD_RELOC_ARC_32_ME_S
3655 ENUMX
3656   BFD_RELOC_ARC_N32_ME
3657 ENUMX
3658   BFD_RELOC_ARC_SECTOFF_ME
3659 ENUMX
3660   BFD_RELOC_ARC_SDA32_ME
3661 ENUMX
3662   BFD_RELOC_ARC_W_ME
3663 ENUMX
3664   BFD_RELOC_AC_SECTOFF_U8
3665 ENUMX
3666   BFD_RELOC_AC_SECTOFF_U8_1
3667 ENUMX
3668   BFD_RELOC_AC_SECTOFF_U8_2
3669 ENUMX
3670   BFD_RELOC_AC_SECTOFF_S9
3671 ENUMX
3672   BFD_RELOC_AC_SECTOFF_S9_1
3673 ENUMX
3674   BFD_RELOC_AC_SECTOFF_S9_2
3675 ENUMX
3676   BFD_RELOC_ARC_SECTOFF_ME_1
3677 ENUMX
3678   BFD_RELOC_ARC_SECTOFF_ME_2
3679 ENUMX
3680   BFD_RELOC_ARC_SECTOFF_1
3681 ENUMX
3682   BFD_RELOC_ARC_SECTOFF_2
3683 ENUMX
3684   BFD_RELOC_ARC_SDA_12
3685 ENUMX
3686   BFD_RELOC_ARC_SDA16_ST2
3687 ENUMX
3688   BFD_RELOC_ARC_32_PCREL
3689 ENUMX
3690   BFD_RELOC_ARC_PC32
3691 ENUMX
3692   BFD_RELOC_ARC_GOT32
3693 ENUMX
3694   BFD_RELOC_ARC_GOTPC32
3695 ENUMX
3696   BFD_RELOC_ARC_PLT32
3697 ENUMX
3698   BFD_RELOC_ARC_COPY
3699 ENUMX
3700   BFD_RELOC_ARC_GLOB_DAT
3701 ENUMX
3702   BFD_RELOC_ARC_JMP_SLOT
3703 ENUMX
3704   BFD_RELOC_ARC_RELATIVE
3705 ENUMX
3706   BFD_RELOC_ARC_GOTOFF
3707 ENUMX
3708   BFD_RELOC_ARC_GOTPC
3709 ENUMX
3710   BFD_RELOC_ARC_S21W_PCREL_PLT
3711 ENUMX
3712   BFD_RELOC_ARC_S25H_PCREL_PLT
3713 ENUMX
3714   BFD_RELOC_ARC_TLS_DTPMOD
3715 ENUMX
3716   BFD_RELOC_ARC_TLS_TPOFF
3717 ENUMX
3718   BFD_RELOC_ARC_TLS_GD_GOT
3719 ENUMX
3720   BFD_RELOC_ARC_TLS_GD_LD
3721 ENUMX
3722   BFD_RELOC_ARC_TLS_GD_CALL
3723 ENUMX
3724   BFD_RELOC_ARC_TLS_IE_GOT
3725 ENUMX
3726   BFD_RELOC_ARC_TLS_DTPOFF
3727 ENUMX
3728   BFD_RELOC_ARC_TLS_DTPOFF_S9
3729 ENUMX
3730   BFD_RELOC_ARC_TLS_LE_S9
3731 ENUMX
3732   BFD_RELOC_ARC_TLS_LE_32
3733 ENUMX
3734   BFD_RELOC_ARC_S25W_PCREL_PLT
3735 ENUMX
3736   BFD_RELOC_ARC_S21H_PCREL_PLT
3737 ENUMX
3738   BFD_RELOC_ARC_NPS_CMEM16
3739 ENUMX
3740   BFD_RELOC_ARC_JLI_SECTOFF
3741 ENUMDOC
3742   ARC relocs.
3743
3744 ENUM
3745   BFD_RELOC_BFIN_16_IMM
3746 ENUMDOC
3747   ADI Blackfin 16 bit immediate absolute reloc.
3748 ENUM
3749   BFD_RELOC_BFIN_16_HIGH
3750 ENUMDOC
3751   ADI Blackfin 16 bit immediate absolute reloc higher 16 bits.
3752 ENUM
3753   BFD_RELOC_BFIN_4_PCREL
3754 ENUMDOC
3755   ADI Blackfin 'a' part of LSETUP.
3756 ENUM
3757   BFD_RELOC_BFIN_5_PCREL
3758 ENUMDOC
3759   ADI Blackfin.
3760 ENUM
3761   BFD_RELOC_BFIN_16_LOW
3762 ENUMDOC
3763   ADI Blackfin 16 bit immediate absolute reloc lower 16 bits.
3764 ENUM
3765   BFD_RELOC_BFIN_10_PCREL
3766 ENUMDOC
3767   ADI Blackfin.
3768 ENUM
3769   BFD_RELOC_BFIN_11_PCREL
3770 ENUMDOC
3771   ADI Blackfin 'b' part of LSETUP.
3772 ENUM
3773   BFD_RELOC_BFIN_12_PCREL_JUMP
3774 ENUMDOC
3775   ADI Blackfin.
3776 ENUM
3777   BFD_RELOC_BFIN_12_PCREL_JUMP_S
3778 ENUMDOC
3779   ADI Blackfin Short jump, pcrel.
3780 ENUM
3781   BFD_RELOC_BFIN_24_PCREL_CALL_X
3782 ENUMDOC
3783   ADI Blackfin Call.x not implemented.
3784 ENUM
3785   BFD_RELOC_BFIN_24_PCREL_JUMP_L
3786 ENUMDOC
3787   ADI Blackfin Long Jump pcrel.
3788 ENUM
3789   BFD_RELOC_BFIN_GOT17M4
3790 ENUMX
3791   BFD_RELOC_BFIN_GOTHI
3792 ENUMX
3793   BFD_RELOC_BFIN_GOTLO
3794 ENUMX
3795   BFD_RELOC_BFIN_FUNCDESC
3796 ENUMX
3797   BFD_RELOC_BFIN_FUNCDESC_GOT17M4
3798 ENUMX
3799   BFD_RELOC_BFIN_FUNCDESC_GOTHI
3800 ENUMX
3801   BFD_RELOC_BFIN_FUNCDESC_GOTLO
3802 ENUMX
3803   BFD_RELOC_BFIN_FUNCDESC_VALUE
3804 ENUMX
3805   BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4
3806 ENUMX
3807   BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI
3808 ENUMX
3809   BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO
3810 ENUMX
3811   BFD_RELOC_BFIN_GOTOFF17M4
3812 ENUMX
3813   BFD_RELOC_BFIN_GOTOFFHI
3814 ENUMX
3815   BFD_RELOC_BFIN_GOTOFFLO
3816 ENUMDOC
3817   ADI Blackfin FD-PIC relocations.
3818 ENUM
3819   BFD_RELOC_BFIN_GOT
3820 ENUMDOC
3821   ADI Blackfin GOT relocation.
3822 ENUM
3823   BFD_RELOC_BFIN_PLTPC
3824 ENUMDOC
3825   ADI Blackfin PLTPC relocation.
3826 ENUM
3827   BFD_ARELOC_BFIN_PUSH
3828 ENUMDOC
3829   ADI Blackfin arithmetic relocation.
3830 ENUM
3831   BFD_ARELOC_BFIN_CONST
3832 ENUMDOC
3833   ADI Blackfin arithmetic relocation.
3834 ENUM
3835   BFD_ARELOC_BFIN_ADD
3836 ENUMDOC
3837   ADI Blackfin arithmetic relocation.
3838 ENUM
3839   BFD_ARELOC_BFIN_SUB
3840 ENUMDOC
3841   ADI Blackfin arithmetic relocation.
3842 ENUM
3843   BFD_ARELOC_BFIN_MULT
3844 ENUMDOC
3845   ADI Blackfin arithmetic relocation.
3846 ENUM
3847   BFD_ARELOC_BFIN_DIV
3848 ENUMDOC
3849   ADI Blackfin arithmetic relocation.
3850 ENUM
3851   BFD_ARELOC_BFIN_MOD
3852 ENUMDOC
3853   ADI Blackfin arithmetic relocation.
3854 ENUM
3855   BFD_ARELOC_BFIN_LSHIFT
3856 ENUMDOC
3857   ADI Blackfin arithmetic relocation.
3858 ENUM
3859   BFD_ARELOC_BFIN_RSHIFT
3860 ENUMDOC
3861   ADI Blackfin arithmetic relocation.
3862 ENUM
3863   BFD_ARELOC_BFIN_AND
3864 ENUMDOC
3865   ADI Blackfin arithmetic relocation.
3866 ENUM
3867   BFD_ARELOC_BFIN_OR
3868 ENUMDOC
3869   ADI Blackfin arithmetic relocation.
3870 ENUM
3871   BFD_ARELOC_BFIN_XOR
3872 ENUMDOC
3873   ADI Blackfin arithmetic relocation.
3874 ENUM
3875   BFD_ARELOC_BFIN_LAND
3876 ENUMDOC
3877   ADI Blackfin arithmetic relocation.
3878 ENUM
3879   BFD_ARELOC_BFIN_LOR
3880 ENUMDOC
3881   ADI Blackfin arithmetic relocation.
3882 ENUM
3883   BFD_ARELOC_BFIN_LEN
3884 ENUMDOC
3885   ADI Blackfin arithmetic relocation.
3886 ENUM
3887   BFD_ARELOC_BFIN_NEG
3888 ENUMDOC
3889   ADI Blackfin arithmetic relocation.
3890 ENUM
3891   BFD_ARELOC_BFIN_COMP
3892 ENUMDOC
3893   ADI Blackfin arithmetic relocation.
3894 ENUM
3895   BFD_ARELOC_BFIN_PAGE
3896 ENUMDOC
3897   ADI Blackfin arithmetic relocation.
3898 ENUM
3899   BFD_ARELOC_BFIN_HWPAGE
3900 ENUMDOC
3901   ADI Blackfin arithmetic relocation.
3902 ENUM
3903   BFD_ARELOC_BFIN_ADDR
3904 ENUMDOC
3905   ADI Blackfin arithmetic relocation.
3906
3907 ENUM
3908   BFD_RELOC_D10V_10_PCREL_R
3909 ENUMDOC
3910   Mitsubishi D10V relocs.
3911   This is a 10-bit reloc with the right 2 bits
3912   assumed to be 0.
3913 ENUM
3914   BFD_RELOC_D10V_10_PCREL_L
3915 ENUMDOC
3916   Mitsubishi D10V relocs.
3917   This is a 10-bit reloc with the right 2 bits
3918   assumed to be 0.  This is the same as the previous reloc
3919   except it is in the left container, i.e.,
3920   shifted left 15 bits.
3921 ENUM
3922   BFD_RELOC_D10V_18
3923 ENUMDOC
3924   This is an 18-bit reloc with the right 2 bits
3925   assumed to be 0.
3926 ENUM
3927   BFD_RELOC_D10V_18_PCREL
3928 ENUMDOC
3929   This is an 18-bit reloc with the right 2 bits
3930   assumed to be 0.
3931
3932 ENUM
3933   BFD_RELOC_D30V_6
3934 ENUMDOC
3935   Mitsubishi D30V relocs.
3936   This is a 6-bit absolute reloc.
3937 ENUM
3938   BFD_RELOC_D30V_9_PCREL
3939 ENUMDOC
3940   This is a 6-bit pc-relative reloc with
3941   the right 3 bits assumed to be 0.
3942 ENUM
3943   BFD_RELOC_D30V_9_PCREL_R
3944 ENUMDOC
3945   This is a 6-bit pc-relative reloc with
3946   the right 3 bits assumed to be 0. Same
3947   as the previous reloc but on the right side
3948   of the container.
3949 ENUM
3950   BFD_RELOC_D30V_15
3951 ENUMDOC
3952   This is a 12-bit absolute reloc with the
3953   right 3 bitsassumed to be 0.
3954 ENUM
3955   BFD_RELOC_D30V_15_PCREL
3956 ENUMDOC
3957   This is a 12-bit pc-relative reloc with
3958   the right 3 bits assumed to be 0.
3959 ENUM
3960   BFD_RELOC_D30V_15_PCREL_R
3961 ENUMDOC
3962   This is a 12-bit pc-relative reloc with
3963   the right 3 bits assumed to be 0. Same
3964   as the previous reloc but on the right side
3965   of the container.
3966 ENUM
3967   BFD_RELOC_D30V_21
3968 ENUMDOC
3969   This is an 18-bit absolute reloc with
3970   the right 3 bits assumed to be 0.
3971 ENUM
3972   BFD_RELOC_D30V_21_PCREL
3973 ENUMDOC
3974   This is an 18-bit pc-relative reloc with
3975   the right 3 bits assumed to be 0.
3976 ENUM
3977   BFD_RELOC_D30V_21_PCREL_R
3978 ENUMDOC
3979   This is an 18-bit pc-relative reloc with
3980   the right 3 bits assumed to be 0. Same
3981   as the previous reloc but on the right side
3982   of the container.
3983 ENUM
3984   BFD_RELOC_D30V_32
3985 ENUMDOC
3986   This is a 32-bit absolute reloc.
3987 ENUM
3988   BFD_RELOC_D30V_32_PCREL
3989 ENUMDOC
3990   This is a 32-bit pc-relative reloc.
3991
3992 ENUM
3993   BFD_RELOC_DLX_HI16_S
3994 ENUMDOC
3995   DLX relocs
3996 ENUM
3997   BFD_RELOC_DLX_LO16
3998 ENUMDOC
3999   DLX relocs
4000 ENUM
4001   BFD_RELOC_DLX_JMP26
4002 ENUMDOC
4003   DLX relocs
4004
4005 ENUM
4006   BFD_RELOC_M32C_HI8
4007 ENUMX
4008   BFD_RELOC_M32C_RL_JUMP
4009 ENUMX
4010   BFD_RELOC_M32C_RL_1ADDR
4011 ENUMX
4012   BFD_RELOC_M32C_RL_2ADDR
4013 ENUMDOC
4014   Renesas M16C/M32C Relocations.
4015
4016 ENUM
4017   BFD_RELOC_M32R_24
4018 ENUMDOC
4019   Renesas M32R (formerly Mitsubishi M32R) relocs.
4020   This is a 24 bit absolute address.
4021 ENUM
4022   BFD_RELOC_M32R_10_PCREL
4023 ENUMDOC
4024   This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
4025 ENUM
4026   BFD_RELOC_M32R_18_PCREL
4027 ENUMDOC
4028   This is an 18-bit reloc with the right 2 bits assumed to be 0.
4029 ENUM
4030   BFD_RELOC_M32R_26_PCREL
4031 ENUMDOC
4032   This is a 26-bit reloc with the right 2 bits assumed to be 0.
4033 ENUM
4034   BFD_RELOC_M32R_HI16_ULO
4035 ENUMDOC
4036   This is a 16-bit reloc containing the high 16 bits of an address
4037   used when the lower 16 bits are treated as unsigned.
4038 ENUM
4039   BFD_RELOC_M32R_HI16_SLO
4040 ENUMDOC
4041   This is a 16-bit reloc containing the high 16 bits of an address
4042   used when the lower 16 bits are treated as signed.
4043 ENUM
4044   BFD_RELOC_M32R_LO16
4045 ENUMDOC
4046   This is a 16-bit reloc containing the lower 16 bits of an address.
4047 ENUM
4048   BFD_RELOC_M32R_SDA16
4049 ENUMDOC
4050   This is a 16-bit reloc containing the small data area offset for use in
4051   add3, load, and store instructions.
4052 ENUM
4053   BFD_RELOC_M32R_GOT24
4054 ENUMX
4055   BFD_RELOC_M32R_26_PLTREL
4056 ENUMX
4057   BFD_RELOC_M32R_COPY
4058 ENUMX
4059   BFD_RELOC_M32R_GLOB_DAT
4060 ENUMX
4061   BFD_RELOC_M32R_JMP_SLOT
4062 ENUMX
4063   BFD_RELOC_M32R_RELATIVE
4064 ENUMX
4065   BFD_RELOC_M32R_GOTOFF
4066 ENUMX
4067   BFD_RELOC_M32R_GOTOFF_HI_ULO
4068 ENUMX
4069   BFD_RELOC_M32R_GOTOFF_HI_SLO
4070 ENUMX
4071   BFD_RELOC_M32R_GOTOFF_LO
4072 ENUMX
4073   BFD_RELOC_M32R_GOTPC24
4074 ENUMX
4075   BFD_RELOC_M32R_GOT16_HI_ULO
4076 ENUMX
4077   BFD_RELOC_M32R_GOT16_HI_SLO
4078 ENUMX
4079   BFD_RELOC_M32R_GOT16_LO
4080 ENUMX
4081   BFD_RELOC_M32R_GOTPC_HI_ULO
4082 ENUMX
4083   BFD_RELOC_M32R_GOTPC_HI_SLO
4084 ENUMX
4085   BFD_RELOC_M32R_GOTPC_LO
4086 ENUMDOC
4087   For PIC.
4088
4089
4090 ENUM
4091   BFD_RELOC_NDS32_20
4092 ENUMDOC
4093   NDS32 relocs.
4094   This is a 20 bit absolute address.
4095 ENUM
4096   BFD_RELOC_NDS32_9_PCREL
4097 ENUMDOC
4098   This is a 9-bit pc-relative reloc with the right 1 bit assumed to be 0.
4099 ENUM
4100   BFD_RELOC_NDS32_WORD_9_PCREL
4101 ENUMDOC
4102   This is a 9-bit pc-relative reloc with the right 1 bit assumed to be 0.
4103 ENUM
4104   BFD_RELOC_NDS32_15_PCREL
4105 ENUMDOC
4106   This is an 15-bit reloc with the right 1 bit assumed to be 0.
4107 ENUM
4108   BFD_RELOC_NDS32_17_PCREL
4109 ENUMDOC
4110   This is an 17-bit reloc with the right 1 bit assumed to be 0.
4111 ENUM
4112   BFD_RELOC_NDS32_25_PCREL
4113 ENUMDOC
4114   This is a 25-bit reloc with the right 1 bit assumed to be 0.
4115 ENUM
4116   BFD_RELOC_NDS32_HI20
4117 ENUMDOC
4118   This is a 20-bit reloc containing the high 20 bits of an address
4119   used with the lower 12 bits
4120 ENUM
4121   BFD_RELOC_NDS32_LO12S3
4122 ENUMDOC
4123   This is a 12-bit reloc containing the lower 12 bits of an address
4124   then shift right by 3. This is used with ldi,sdi...
4125 ENUM
4126   BFD_RELOC_NDS32_LO12S2
4127 ENUMDOC
4128   This is a 12-bit reloc containing the lower 12 bits of an address
4129   then shift left by 2. This is used with lwi,swi...
4130 ENUM
4131   BFD_RELOC_NDS32_LO12S1
4132 ENUMDOC
4133   This is a 12-bit reloc containing the lower 12 bits of an address
4134   then shift left by 1. This is used with lhi,shi...
4135 ENUM
4136   BFD_RELOC_NDS32_LO12S0
4137 ENUMDOC
4138   This is a 12-bit reloc containing the lower 12 bits of an address
4139   then shift left by 0. This is used with lbisbi...
4140 ENUM
4141   BFD_RELOC_NDS32_LO12S0_ORI
4142 ENUMDOC
4143   This is a 12-bit reloc containing the lower 12 bits of an address
4144   then shift left by 0. This is only used with branch relaxations
4145 ENUM
4146   BFD_RELOC_NDS32_SDA15S3
4147 ENUMDOC
4148   This is a 15-bit reloc containing the small data area 18-bit signed offset
4149   and shift left by 3 for use in ldi, sdi...
4150 ENUM
4151   BFD_RELOC_NDS32_SDA15S2
4152 ENUMDOC
4153   This is a 15-bit reloc containing the small data area 17-bit signed offset
4154   and shift left by 2 for use in lwi, swi...
4155 ENUM
4156   BFD_RELOC_NDS32_SDA15S1
4157 ENUMDOC
4158   This is a 15-bit reloc containing the small data area 16-bit signed offset
4159   and shift left by 1 for use in lhi, shi...
4160 ENUM
4161   BFD_RELOC_NDS32_SDA15S0
4162 ENUMDOC
4163   This is a 15-bit reloc containing the small data area 15-bit signed offset
4164   and shift left by 0 for use in lbi, sbi...
4165 ENUM
4166   BFD_RELOC_NDS32_SDA16S3
4167 ENUMDOC
4168   This is a 16-bit reloc containing the small data area 16-bit signed offset
4169   and shift left by 3
4170 ENUM
4171   BFD_RELOC_NDS32_SDA17S2
4172 ENUMDOC
4173   This is a 17-bit reloc containing the small data area 17-bit signed offset
4174   and shift left by 2 for use in lwi.gp, swi.gp...
4175 ENUM
4176   BFD_RELOC_NDS32_SDA18S1
4177 ENUMDOC
4178   This is a 18-bit reloc containing the small data area 18-bit signed offset
4179   and shift left by 1 for use in lhi.gp, shi.gp...
4180 ENUM
4181   BFD_RELOC_NDS32_SDA19S0
4182 ENUMDOC
4183   This is a 19-bit reloc containing the small data area 19-bit signed offset
4184   and shift left by 0 for use in lbi.gp, sbi.gp...
4185 ENUM
4186   BFD_RELOC_NDS32_GOT20
4187 ENUMX
4188   BFD_RELOC_NDS32_9_PLTREL
4189 ENUMX
4190   BFD_RELOC_NDS32_25_PLTREL
4191 ENUMX
4192   BFD_RELOC_NDS32_COPY
4193 ENUMX
4194   BFD_RELOC_NDS32_GLOB_DAT
4195 ENUMX
4196   BFD_RELOC_NDS32_JMP_SLOT
4197 ENUMX
4198   BFD_RELOC_NDS32_RELATIVE
4199 ENUMX
4200   BFD_RELOC_NDS32_GOTOFF
4201 ENUMX
4202   BFD_RELOC_NDS32_GOTOFF_HI20
4203 ENUMX
4204   BFD_RELOC_NDS32_GOTOFF_LO12
4205 ENUMX
4206   BFD_RELOC_NDS32_GOTPC20
4207 ENUMX
4208   BFD_RELOC_NDS32_GOT_HI20
4209 ENUMX
4210   BFD_RELOC_NDS32_GOT_LO12
4211 ENUMX
4212   BFD_RELOC_NDS32_GOTPC_HI20
4213 ENUMX
4214   BFD_RELOC_NDS32_GOTPC_LO12
4215 ENUMDOC
4216   for PIC
4217 ENUM
4218   BFD_RELOC_NDS32_INSN16
4219 ENUMX
4220   BFD_RELOC_NDS32_LABEL
4221 ENUMX
4222   BFD_RELOC_NDS32_LONGCALL1
4223 ENUMX
4224   BFD_RELOC_NDS32_LONGCALL2
4225 ENUMX
4226   BFD_RELOC_NDS32_LONGCALL3
4227 ENUMX
4228   BFD_RELOC_NDS32_LONGJUMP1
4229 ENUMX
4230   BFD_RELOC_NDS32_LONGJUMP2
4231 ENUMX
4232   BFD_RELOC_NDS32_LONGJUMP3
4233 ENUMX
4234   BFD_RELOC_NDS32_LOADSTORE
4235 ENUMX
4236   BFD_RELOC_NDS32_9_FIXED
4237 ENUMX
4238   BFD_RELOC_NDS32_15_FIXED
4239 ENUMX
4240   BFD_RELOC_NDS32_17_FIXED
4241 ENUMX
4242   BFD_RELOC_NDS32_25_FIXED
4243 ENUMX
4244   BFD_RELOC_NDS32_LONGCALL4
4245 ENUMX
4246   BFD_RELOC_NDS32_LONGCALL5
4247 ENUMX
4248   BFD_RELOC_NDS32_LONGCALL6
4249 ENUMX
4250   BFD_RELOC_NDS32_LONGJUMP4
4251 ENUMX
4252   BFD_RELOC_NDS32_LONGJUMP5
4253 ENUMX
4254   BFD_RELOC_NDS32_LONGJUMP6
4255 ENUMX
4256   BFD_RELOC_NDS32_LONGJUMP7
4257 ENUMDOC
4258   for relax
4259 ENUM
4260   BFD_RELOC_NDS32_PLTREL_HI20
4261 ENUMX
4262   BFD_RELOC_NDS32_PLTREL_LO12
4263 ENUMX
4264   BFD_RELOC_NDS32_PLT_GOTREL_HI20
4265 ENUMX
4266   BFD_RELOC_NDS32_PLT_GOTREL_LO12
4267 ENUMDOC
4268   for PIC
4269 ENUM
4270   BFD_RELOC_NDS32_SDA12S2_DP
4271 ENUMX
4272   BFD_RELOC_NDS32_SDA12S2_SP
4273 ENUMX
4274   BFD_RELOC_NDS32_LO12S2_DP
4275 ENUMX
4276   BFD_RELOC_NDS32_LO12S2_SP
4277 ENUMDOC
4278   for floating point
4279 ENUM
4280   BFD_RELOC_NDS32_DWARF2_OP1
4281 ENUMX
4282   BFD_RELOC_NDS32_DWARF2_OP2
4283 ENUMX
4284   BFD_RELOC_NDS32_DWARF2_LEB
4285 ENUMDOC
4286   for dwarf2 debug_line.
4287 ENUM
4288   BFD_RELOC_NDS32_UPDATE_TA
4289 ENUMDOC
4290   for eliminate 16-bit instructions
4291 ENUM
4292   BFD_RELOC_NDS32_PLT_GOTREL_LO20
4293 ENUMX
4294   BFD_RELOC_NDS32_PLT_GOTREL_LO15
4295 ENUMX
4296   BFD_RELOC_NDS32_PLT_GOTREL_LO19
4297 ENUMX
4298   BFD_RELOC_NDS32_GOT_LO15
4299 ENUMX
4300   BFD_RELOC_NDS32_GOT_LO19
4301 ENUMX
4302   BFD_RELOC_NDS32_GOTOFF_LO15
4303 ENUMX
4304   BFD_RELOC_NDS32_GOTOFF_LO19
4305 ENUMX
4306   BFD_RELOC_NDS32_GOT15S2
4307 ENUMX
4308   BFD_RELOC_NDS32_GOT17S2
4309 ENUMDOC
4310   for PIC object relaxation
4311 ENUM
4312   BFD_RELOC_NDS32_5
4313 ENUMDOC
4314   NDS32 relocs.
4315   This is a 5 bit absolute address.
4316 ENUM
4317   BFD_RELOC_NDS32_10_UPCREL
4318 ENUMDOC
4319   This is a 10-bit unsigned pc-relative reloc with the right 1 bit assumed to be 0.
4320 ENUM
4321   BFD_RELOC_NDS32_SDA_FP7U2_RELA
4322 ENUMDOC
4323   If fp were omitted, fp can used as another gp.
4324 ENUM
4325   BFD_RELOC_NDS32_RELAX_ENTRY
4326 ENUMX
4327   BFD_RELOC_NDS32_GOT_SUFF
4328 ENUMX
4329   BFD_RELOC_NDS32_GOTOFF_SUFF
4330 ENUMX
4331   BFD_RELOC_NDS32_PLT_GOT_SUFF
4332 ENUMX
4333   BFD_RELOC_NDS32_MULCALL_SUFF
4334 ENUMX
4335   BFD_RELOC_NDS32_PTR
4336 ENUMX
4337   BFD_RELOC_NDS32_PTR_COUNT
4338 ENUMX
4339   BFD_RELOC_NDS32_PTR_RESOLVED
4340 ENUMX
4341   BFD_RELOC_NDS32_PLTBLOCK
4342 ENUMX
4343   BFD_RELOC_NDS32_RELAX_REGION_BEGIN
4344 ENUMX
4345   BFD_RELOC_NDS32_RELAX_REGION_END
4346 ENUMX
4347   BFD_RELOC_NDS32_MINUEND
4348 ENUMX
4349   BFD_RELOC_NDS32_SUBTRAHEND
4350 ENUMX
4351   BFD_RELOC_NDS32_DIFF8
4352 ENUMX
4353   BFD_RELOC_NDS32_DIFF16
4354 ENUMX
4355   BFD_RELOC_NDS32_DIFF32
4356 ENUMX
4357   BFD_RELOC_NDS32_DIFF_ULEB128
4358 ENUMX
4359   BFD_RELOC_NDS32_EMPTY
4360 ENUMDOC
4361   relaxation relative relocation types
4362 ENUM
4363   BFD_RELOC_NDS32_25_ABS
4364 ENUMDOC
4365   This is a 25 bit absolute address.
4366 ENUM
4367   BFD_RELOC_NDS32_DATA
4368 ENUMX
4369   BFD_RELOC_NDS32_TRAN
4370 ENUMX
4371   BFD_RELOC_NDS32_17IFC_PCREL
4372 ENUMX
4373   BFD_RELOC_NDS32_10IFCU_PCREL
4374 ENUMDOC
4375   For ex9 and ifc using.
4376 ENUM
4377   BFD_RELOC_NDS32_TPOFF
4378 ENUMX
4379   BFD_RELOC_NDS32_GOTTPOFF
4380 ENUMX
4381   BFD_RELOC_NDS32_TLS_LE_HI20
4382 ENUMX
4383   BFD_RELOC_NDS32_TLS_LE_LO12
4384 ENUMX
4385   BFD_RELOC_NDS32_TLS_LE_20
4386 ENUMX
4387   BFD_RELOC_NDS32_TLS_LE_15S0
4388 ENUMX
4389   BFD_RELOC_NDS32_TLS_LE_15S1
4390 ENUMX
4391   BFD_RELOC_NDS32_TLS_LE_15S2
4392 ENUMX
4393   BFD_RELOC_NDS32_TLS_LE_ADD
4394 ENUMX
4395   BFD_RELOC_NDS32_TLS_LE_LS
4396 ENUMX
4397   BFD_RELOC_NDS32_TLS_IE_HI20
4398 ENUMX
4399   BFD_RELOC_NDS32_TLS_IE_LO12
4400 ENUMX
4401   BFD_RELOC_NDS32_TLS_IE_LO12S2
4402 ENUMX
4403   BFD_RELOC_NDS32_TLS_IEGP_HI20
4404 ENUMX
4405   BFD_RELOC_NDS32_TLS_IEGP_LO12
4406 ENUMX
4407   BFD_RELOC_NDS32_TLS_IEGP_LO12S2
4408 ENUMX
4409   BFD_RELOC_NDS32_TLS_IEGP_LW
4410 ENUMX
4411   BFD_RELOC_NDS32_TLS_DESC
4412 ENUMX
4413   BFD_RELOC_NDS32_TLS_DESC_HI20
4414 ENUMX
4415   BFD_RELOC_NDS32_TLS_DESC_LO12
4416 ENUMX
4417   BFD_RELOC_NDS32_TLS_DESC_20
4418 ENUMX
4419   BFD_RELOC_NDS32_TLS_DESC_SDA17S2
4420 ENUMX
4421   BFD_RELOC_NDS32_TLS_DESC_ADD
4422 ENUMX
4423   BFD_RELOC_NDS32_TLS_DESC_FUNC
4424 ENUMX
4425   BFD_RELOC_NDS32_TLS_DESC_CALL
4426 ENUMX
4427   BFD_RELOC_NDS32_TLS_DESC_MEM
4428 ENUMX
4429   BFD_RELOC_NDS32_REMOVE
4430 ENUMX
4431   BFD_RELOC_NDS32_GROUP
4432 ENUMDOC
4433   For TLS.
4434 ENUM
4435   BFD_RELOC_NDS32_LSI
4436 ENUMDOC
4437   For floating load store relaxation.
4438
4439
4440 ENUM
4441   BFD_RELOC_V850_9_PCREL
4442 ENUMDOC
4443   This is a 9-bit reloc
4444 ENUM
4445   BFD_RELOC_V850_22_PCREL
4446 ENUMDOC
4447   This is a 22-bit reloc
4448
4449 ENUM
4450   BFD_RELOC_V850_SDA_16_16_OFFSET
4451 ENUMDOC
4452   This is a 16 bit offset from the short data area pointer.
4453 ENUM
4454   BFD_RELOC_V850_SDA_15_16_OFFSET
4455 ENUMDOC
4456   This is a 16 bit offset (of which only 15 bits are used) from the
4457   short data area pointer.
4458 ENUM
4459   BFD_RELOC_V850_ZDA_16_16_OFFSET
4460 ENUMDOC
4461   This is a 16 bit offset from the zero data area pointer.
4462 ENUM
4463   BFD_RELOC_V850_ZDA_15_16_OFFSET
4464 ENUMDOC
4465   This is a 16 bit offset (of which only 15 bits are used) from the
4466   zero data area pointer.
4467 ENUM
4468   BFD_RELOC_V850_TDA_6_8_OFFSET
4469 ENUMDOC
4470   This is an 8 bit offset (of which only 6 bits are used) from the
4471   tiny data area pointer.
4472 ENUM
4473   BFD_RELOC_V850_TDA_7_8_OFFSET
4474 ENUMDOC
4475   This is an 8bit offset (of which only 7 bits are used) from the tiny
4476   data area pointer.
4477 ENUM
4478   BFD_RELOC_V850_TDA_7_7_OFFSET
4479 ENUMDOC
4480   This is a 7 bit offset from the tiny data area pointer.
4481 ENUM
4482   BFD_RELOC_V850_TDA_16_16_OFFSET
4483 ENUMDOC
4484   This is a 16 bit offset from the tiny data area pointer.
4485 COMMENT
4486 ENUM
4487   BFD_RELOC_V850_TDA_4_5_OFFSET
4488 ENUMDOC
4489   This is a 5 bit offset (of which only 4 bits are used) from the tiny
4490   data area pointer.
4491 ENUM
4492   BFD_RELOC_V850_TDA_4_4_OFFSET
4493 ENUMDOC
4494   This is a 4 bit offset from the tiny data area pointer.
4495 ENUM
4496   BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
4497 ENUMDOC
4498   This is a 16 bit offset from the short data area pointer, with the
4499   bits placed non-contiguously in the instruction.
4500 ENUM
4501   BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
4502 ENUMDOC
4503   This is a 16 bit offset from the zero data area pointer, with the
4504   bits placed non-contiguously in the instruction.
4505 ENUM
4506   BFD_RELOC_V850_CALLT_6_7_OFFSET
4507 ENUMDOC
4508   This is a 6 bit offset from the call table base pointer.
4509 ENUM
4510   BFD_RELOC_V850_CALLT_16_16_OFFSET
4511 ENUMDOC
4512   This is a 16 bit offset from the call table base pointer.
4513 ENUM
4514   BFD_RELOC_V850_LONGCALL
4515 ENUMDOC
4516   Used for relaxing indirect function calls.
4517 ENUM
4518   BFD_RELOC_V850_LONGJUMP
4519 ENUMDOC
4520   Used for relaxing indirect jumps.
4521 ENUM
4522   BFD_RELOC_V850_ALIGN
4523 ENUMDOC
4524   Used to maintain alignment whilst relaxing.
4525 ENUM
4526   BFD_RELOC_V850_LO16_SPLIT_OFFSET
4527 ENUMDOC
4528   This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu
4529   instructions.
4530 ENUM
4531   BFD_RELOC_V850_16_PCREL
4532 ENUMDOC
4533   This is a 16-bit reloc.
4534 ENUM
4535   BFD_RELOC_V850_17_PCREL
4536 ENUMDOC
4537   This is a 17-bit reloc.
4538 ENUM
4539   BFD_RELOC_V850_23
4540 ENUMDOC
4541   This is a 23-bit reloc.
4542 ENUM
4543   BFD_RELOC_V850_32_PCREL
4544 ENUMDOC
4545   This is a 32-bit reloc.
4546 ENUM
4547   BFD_RELOC_V850_32_ABS
4548 ENUMDOC
4549   This is a 32-bit reloc.
4550 ENUM
4551   BFD_RELOC_V850_16_SPLIT_OFFSET
4552 ENUMDOC
4553   This is a 16-bit reloc.
4554 ENUM
4555   BFD_RELOC_V850_16_S1
4556 ENUMDOC
4557   This is a 16-bit reloc.
4558 ENUM
4559   BFD_RELOC_V850_LO16_S1
4560 ENUMDOC
4561   Low 16 bits. 16 bit shifted by 1.
4562 ENUM
4563   BFD_RELOC_V850_CALLT_15_16_OFFSET
4564 ENUMDOC
4565   This is a 16 bit offset from the call table base pointer.
4566 ENUM
4567   BFD_RELOC_V850_32_GOTPCREL
4568 ENUMDOC
4569   DSO relocations.
4570 ENUM
4571   BFD_RELOC_V850_16_GOT
4572 ENUMDOC
4573   DSO relocations.
4574 ENUM
4575   BFD_RELOC_V850_32_GOT
4576 ENUMDOC
4577   DSO relocations.
4578 ENUM
4579   BFD_RELOC_V850_22_PLT_PCREL
4580 ENUMDOC
4581   DSO relocations.
4582 ENUM
4583   BFD_RELOC_V850_32_PLT_PCREL
4584 ENUMDOC
4585   DSO relocations.
4586 ENUM
4587   BFD_RELOC_V850_COPY
4588 ENUMDOC
4589   DSO relocations.
4590 ENUM
4591   BFD_RELOC_V850_GLOB_DAT
4592 ENUMDOC
4593   DSO relocations.
4594 ENUM
4595   BFD_RELOC_V850_JMP_SLOT
4596 ENUMDOC
4597   DSO relocations.
4598 ENUM
4599   BFD_RELOC_V850_RELATIVE
4600 ENUMDOC
4601   DSO relocations.
4602 ENUM
4603   BFD_RELOC_V850_16_GOTOFF
4604 ENUMDOC
4605   DSO relocations.
4606 ENUM
4607   BFD_RELOC_V850_32_GOTOFF
4608 ENUMDOC
4609   DSO relocations.
4610 ENUM
4611   BFD_RELOC_V850_CODE
4612 ENUMDOC
4613   start code.
4614 ENUM
4615   BFD_RELOC_V850_DATA
4616 ENUMDOC
4617   start data in text.
4618
4619 ENUM
4620   BFD_RELOC_TIC30_LDP
4621 ENUMDOC
4622   This is a 8bit DP reloc for the tms320c30, where the most
4623   significant 8 bits of a 24 bit word are placed into the least
4624   significant 8 bits of the opcode.
4625
4626 ENUM
4627   BFD_RELOC_TIC54X_PARTLS7
4628 ENUMDOC
4629   This is a 7bit reloc for the tms320c54x, where the least
4630   significant 7 bits of a 16 bit word are placed into the least
4631   significant 7 bits of the opcode.
4632
4633 ENUM
4634   BFD_RELOC_TIC54X_PARTMS9
4635 ENUMDOC
4636   This is a 9bit DP reloc for the tms320c54x, where the most
4637   significant 9 bits of a 16 bit word are placed into the least
4638   significant 9 bits of the opcode.
4639
4640 ENUM
4641   BFD_RELOC_TIC54X_23
4642 ENUMDOC
4643   This is an extended address 23-bit reloc for the tms320c54x.
4644
4645 ENUM
4646   BFD_RELOC_TIC54X_16_OF_23
4647 ENUMDOC
4648   This is a 16-bit reloc for the tms320c54x, where the least
4649   significant 16 bits of a 23-bit extended address are placed into
4650   the opcode.
4651
4652 ENUM
4653   BFD_RELOC_TIC54X_MS7_OF_23
4654 ENUMDOC
4655   This is a reloc for the tms320c54x, where the most
4656   significant 7 bits of a 23-bit extended address are placed into
4657   the opcode.
4658
4659 ENUM
4660   BFD_RELOC_C6000_PCR_S21
4661 ENUMX
4662   BFD_RELOC_C6000_PCR_S12
4663 ENUMX
4664   BFD_RELOC_C6000_PCR_S10
4665 ENUMX
4666   BFD_RELOC_C6000_PCR_S7
4667 ENUMX
4668   BFD_RELOC_C6000_ABS_S16
4669 ENUMX
4670   BFD_RELOC_C6000_ABS_L16
4671 ENUMX
4672   BFD_RELOC_C6000_ABS_H16
4673 ENUMX
4674   BFD_RELOC_C6000_SBR_U15_B
4675 ENUMX
4676   BFD_RELOC_C6000_SBR_U15_H
4677 ENUMX
4678   BFD_RELOC_C6000_SBR_U15_W
4679 ENUMX
4680   BFD_RELOC_C6000_SBR_S16
4681 ENUMX
4682   BFD_RELOC_C6000_SBR_L16_B
4683 ENUMX
4684   BFD_RELOC_C6000_SBR_L16_H
4685 ENUMX
4686   BFD_RELOC_C6000_SBR_L16_W
4687 ENUMX
4688   BFD_RELOC_C6000_SBR_H16_B
4689 ENUMX
4690   BFD_RELOC_C6000_SBR_H16_H
4691 ENUMX
4692   BFD_RELOC_C6000_SBR_H16_W
4693 ENUMX
4694   BFD_RELOC_C6000_SBR_GOT_U15_W
4695 ENUMX
4696   BFD_RELOC_C6000_SBR_GOT_L16_W
4697 ENUMX
4698   BFD_RELOC_C6000_SBR_GOT_H16_W
4699 ENUMX
4700   BFD_RELOC_C6000_DSBT_INDEX
4701 ENUMX
4702   BFD_RELOC_C6000_PREL31
4703 ENUMX
4704   BFD_RELOC_C6000_COPY
4705 ENUMX
4706   BFD_RELOC_C6000_JUMP_SLOT
4707 ENUMX
4708   BFD_RELOC_C6000_EHTYPE
4709 ENUMX
4710   BFD_RELOC_C6000_PCR_H16
4711 ENUMX
4712   BFD_RELOC_C6000_PCR_L16
4713 ENUMX
4714   BFD_RELOC_C6000_ALIGN
4715 ENUMX
4716   BFD_RELOC_C6000_FPHEAD
4717 ENUMX
4718   BFD_RELOC_C6000_NOCMP
4719 ENUMDOC
4720   TMS320C6000 relocations.
4721
4722 ENUM
4723   BFD_RELOC_FR30_48
4724 ENUMDOC
4725   This is a 48 bit reloc for the FR30 that stores 32 bits.
4726 ENUM
4727   BFD_RELOC_FR30_20
4728 ENUMDOC
4729   This is a 32 bit reloc for the FR30 that stores 20 bits split up into
4730   two sections.
4731 ENUM
4732   BFD_RELOC_FR30_6_IN_4
4733 ENUMDOC
4734   This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
4735   4 bits.
4736 ENUM
4737   BFD_RELOC_FR30_8_IN_8
4738 ENUMDOC
4739   This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
4740   into 8 bits.
4741 ENUM
4742   BFD_RELOC_FR30_9_IN_8
4743 ENUMDOC
4744   This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
4745   into 8 bits.
4746 ENUM
4747   BFD_RELOC_FR30_10_IN_8
4748 ENUMDOC
4749   This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
4750   into 8 bits.
4751 ENUM
4752   BFD_RELOC_FR30_9_PCREL
4753 ENUMDOC
4754   This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
4755   short offset into 8 bits.
4756 ENUM
4757   BFD_RELOC_FR30_12_PCREL
4758 ENUMDOC
4759   This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
4760   short offset into 11 bits.
4761
4762 ENUM
4763   BFD_RELOC_MCORE_PCREL_IMM8BY4
4764 ENUMX
4765   BFD_RELOC_MCORE_PCREL_IMM11BY2
4766 ENUMX
4767   BFD_RELOC_MCORE_PCREL_IMM4BY2
4768 ENUMX
4769   BFD_RELOC_MCORE_PCREL_32
4770 ENUMX
4771   BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
4772 ENUMX
4773   BFD_RELOC_MCORE_RVA
4774 ENUMDOC
4775   Motorola Mcore relocations.
4776
4777 ENUM
4778   BFD_RELOC_MEP_8
4779 ENUMX
4780   BFD_RELOC_MEP_16
4781 ENUMX
4782   BFD_RELOC_MEP_32
4783 ENUMX
4784   BFD_RELOC_MEP_PCREL8A2
4785 ENUMX
4786   BFD_RELOC_MEP_PCREL12A2
4787 ENUMX
4788   BFD_RELOC_MEP_PCREL17A2
4789 ENUMX
4790   BFD_RELOC_MEP_PCREL24A2
4791 ENUMX
4792   BFD_RELOC_MEP_PCABS24A2
4793 ENUMX
4794   BFD_RELOC_MEP_LOW16
4795 ENUMX
4796   BFD_RELOC_MEP_HI16U
4797 ENUMX
4798   BFD_RELOC_MEP_HI16S
4799 ENUMX
4800   BFD_RELOC_MEP_GPREL
4801 ENUMX
4802   BFD_RELOC_MEP_TPREL
4803 ENUMX
4804   BFD_RELOC_MEP_TPREL7
4805 ENUMX
4806   BFD_RELOC_MEP_TPREL7A2
4807 ENUMX
4808   BFD_RELOC_MEP_TPREL7A4
4809 ENUMX
4810   BFD_RELOC_MEP_UIMM24
4811 ENUMX
4812   BFD_RELOC_MEP_ADDR24A4
4813 ENUMX
4814   BFD_RELOC_MEP_GNU_VTINHERIT
4815 ENUMX
4816   BFD_RELOC_MEP_GNU_VTENTRY
4817 ENUMDOC
4818   Toshiba Media Processor Relocations.
4819 COMMENT
4820
4821 ENUM
4822   BFD_RELOC_METAG_HIADDR16
4823 ENUMX
4824   BFD_RELOC_METAG_LOADDR16
4825 ENUMX
4826   BFD_RELOC_METAG_RELBRANCH
4827 ENUMX
4828   BFD_RELOC_METAG_GETSETOFF
4829 ENUMX
4830   BFD_RELOC_METAG_HIOG
4831 ENUMX
4832   BFD_RELOC_METAG_LOOG
4833 ENUMX
4834   BFD_RELOC_METAG_REL8
4835 ENUMX
4836   BFD_RELOC_METAG_REL16
4837 ENUMX
4838   BFD_RELOC_METAG_HI16_GOTOFF
4839 ENUMX
4840   BFD_RELOC_METAG_LO16_GOTOFF
4841 ENUMX
4842   BFD_RELOC_METAG_GETSET_GOTOFF
4843 ENUMX
4844   BFD_RELOC_METAG_GETSET_GOT
4845 ENUMX
4846   BFD_RELOC_METAG_HI16_GOTPC
4847 ENUMX
4848   BFD_RELOC_METAG_LO16_GOTPC
4849 ENUMX
4850   BFD_RELOC_METAG_HI16_PLT
4851 ENUMX
4852   BFD_RELOC_METAG_LO16_PLT
4853 ENUMX
4854   BFD_RELOC_METAG_RELBRANCH_PLT
4855 ENUMX
4856   BFD_RELOC_METAG_GOTOFF
4857 ENUMX
4858   BFD_RELOC_METAG_PLT
4859 ENUMX
4860   BFD_RELOC_METAG_COPY
4861 ENUMX
4862   BFD_RELOC_METAG_JMP_SLOT
4863 ENUMX
4864   BFD_RELOC_METAG_RELATIVE
4865 ENUMX
4866   BFD_RELOC_METAG_GLOB_DAT
4867 ENUMX
4868   BFD_RELOC_METAG_TLS_GD
4869 ENUMX
4870   BFD_RELOC_METAG_TLS_LDM
4871 ENUMX
4872   BFD_RELOC_METAG_TLS_LDO_HI16
4873 ENUMX
4874   BFD_RELOC_METAG_TLS_LDO_LO16
4875 ENUMX
4876   BFD_RELOC_METAG_TLS_LDO
4877 ENUMX
4878   BFD_RELOC_METAG_TLS_IE
4879 ENUMX
4880   BFD_RELOC_METAG_TLS_IENONPIC
4881 ENUMX
4882   BFD_RELOC_METAG_TLS_IENONPIC_HI16
4883 ENUMX
4884   BFD_RELOC_METAG_TLS_IENONPIC_LO16
4885 ENUMX
4886   BFD_RELOC_METAG_TLS_TPOFF
4887 ENUMX
4888   BFD_RELOC_METAG_TLS_DTPMOD
4889 ENUMX
4890   BFD_RELOC_METAG_TLS_DTPOFF
4891 ENUMX
4892   BFD_RELOC_METAG_TLS_LE
4893 ENUMX
4894   BFD_RELOC_METAG_TLS_LE_HI16
4895 ENUMX
4896   BFD_RELOC_METAG_TLS_LE_LO16
4897 ENUMDOC
4898   Imagination Technologies Meta relocations.
4899
4900 ENUM
4901   BFD_RELOC_MMIX_GETA
4902 ENUMX
4903   BFD_RELOC_MMIX_GETA_1
4904 ENUMX
4905   BFD_RELOC_MMIX_GETA_2
4906 ENUMX
4907   BFD_RELOC_MMIX_GETA_3
4908 ENUMDOC
4909   These are relocations for the GETA instruction.
4910 ENUM
4911   BFD_RELOC_MMIX_CBRANCH
4912 ENUMX
4913   BFD_RELOC_MMIX_CBRANCH_J
4914 ENUMX
4915   BFD_RELOC_MMIX_CBRANCH_1
4916 ENUMX
4917   BFD_RELOC_MMIX_CBRANCH_2
4918 ENUMX
4919   BFD_RELOC_MMIX_CBRANCH_3
4920 ENUMDOC
4921   These are relocations for a conditional branch instruction.
4922 ENUM
4923   BFD_RELOC_MMIX_PUSHJ
4924 ENUMX
4925   BFD_RELOC_MMIX_PUSHJ_1
4926 ENUMX
4927   BFD_RELOC_MMIX_PUSHJ_2
4928 ENUMX
4929   BFD_RELOC_MMIX_PUSHJ_3
4930 ENUMX
4931   BFD_RELOC_MMIX_PUSHJ_STUBBABLE
4932 ENUMDOC
4933   These are relocations for the PUSHJ instruction.
4934 ENUM
4935   BFD_RELOC_MMIX_JMP
4936 ENUMX
4937   BFD_RELOC_MMIX_JMP_1
4938 ENUMX
4939   BFD_RELOC_MMIX_JMP_2
4940 ENUMX
4941   BFD_RELOC_MMIX_JMP_3
4942 ENUMDOC
4943   These are relocations for the JMP instruction.
4944 ENUM
4945   BFD_RELOC_MMIX_ADDR19
4946 ENUMDOC
4947   This is a relocation for a relative address as in a GETA instruction or
4948   a branch.
4949 ENUM
4950   BFD_RELOC_MMIX_ADDR27
4951 ENUMDOC
4952   This is a relocation for a relative address as in a JMP instruction.
4953 ENUM
4954   BFD_RELOC_MMIX_REG_OR_BYTE
4955 ENUMDOC
4956   This is a relocation for an instruction field that may be a general
4957   register or a value 0..255.
4958 ENUM
4959   BFD_RELOC_MMIX_REG
4960 ENUMDOC
4961   This is a relocation for an instruction field that may be a general
4962   register.
4963 ENUM
4964   BFD_RELOC_MMIX_BASE_PLUS_OFFSET
4965 ENUMDOC
4966   This is a relocation for two instruction fields holding a register and
4967   an offset, the equivalent of the relocation.
4968 ENUM
4969   BFD_RELOC_MMIX_LOCAL
4970 ENUMDOC
4971   This relocation is an assertion that the expression is not allocated as
4972   a global register.  It does not modify contents.
4973
4974 ENUM
4975   BFD_RELOC_AVR_7_PCREL
4976 ENUMDOC
4977   This is a 16 bit reloc for the AVR that stores 8 bit pc relative
4978   short offset into 7 bits.
4979 ENUM
4980   BFD_RELOC_AVR_13_PCREL
4981 ENUMDOC
4982   This is a 16 bit reloc for the AVR that stores 13 bit pc relative
4983   short offset into 12 bits.
4984 ENUM
4985   BFD_RELOC_AVR_16_PM
4986 ENUMDOC
4987   This is a 16 bit reloc for the AVR that stores 17 bit value (usually
4988   program memory address) into 16 bits.
4989 ENUM
4990   BFD_RELOC_AVR_LO8_LDI
4991 ENUMDOC
4992   This is a 16 bit reloc for the AVR that stores 8 bit value (usually
4993   data memory address) into 8 bit immediate value of LDI insn.
4994 ENUM
4995   BFD_RELOC_AVR_HI8_LDI
4996 ENUMDOC
4997   This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
4998   of data memory address) into 8 bit immediate value of LDI insn.
4999 ENUM
5000   BFD_RELOC_AVR_HH8_LDI
5001 ENUMDOC
5002   This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
5003   of program memory address) into 8 bit immediate value of LDI insn.
5004 ENUM
5005   BFD_RELOC_AVR_MS8_LDI
5006 ENUMDOC
5007   This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
5008   of 32 bit value) into 8 bit immediate value of LDI insn.
5009 ENUM
5010   BFD_RELOC_AVR_LO8_LDI_NEG
5011 ENUMDOC
5012   This is a 16 bit reloc for the AVR that stores negated 8 bit value
5013   (usually data memory address) into 8 bit immediate value of SUBI insn.
5014 ENUM
5015   BFD_RELOC_AVR_HI8_LDI_NEG
5016 ENUMDOC
5017   This is a 16 bit reloc for the AVR that stores negated 8 bit value
5018   (high 8 bit of data memory address) into 8 bit immediate value of
5019   SUBI insn.
5020 ENUM
5021   BFD_RELOC_AVR_HH8_LDI_NEG
5022 ENUMDOC
5023   This is a 16 bit reloc for the AVR that stores negated 8 bit value
5024   (most high 8 bit of program memory address) into 8 bit immediate value
5025   of LDI or SUBI insn.
5026 ENUM
5027   BFD_RELOC_AVR_MS8_LDI_NEG
5028 ENUMDOC
5029   This is a 16 bit reloc for the AVR that stores negated 8 bit value (msb
5030   of 32 bit value) into 8 bit immediate value of LDI insn.
5031 ENUM
5032   BFD_RELOC_AVR_LO8_LDI_PM
5033 ENUMDOC
5034   This is a 16 bit reloc for the AVR that stores 8 bit value (usually
5035   command address) into 8 bit immediate value of LDI insn.
5036 ENUM
5037   BFD_RELOC_AVR_LO8_LDI_GS
5038 ENUMDOC
5039   This is a 16 bit reloc for the AVR that stores 8 bit value
5040   (command address) into 8 bit immediate value of LDI insn. If the address
5041   is beyond the 128k boundary, the linker inserts a jump stub for this reloc
5042   in the lower 128k.
5043 ENUM
5044   BFD_RELOC_AVR_HI8_LDI_PM
5045 ENUMDOC
5046   This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
5047   of command address) into 8 bit immediate value of LDI insn.
5048 ENUM
5049   BFD_RELOC_AVR_HI8_LDI_GS
5050 ENUMDOC
5051   This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
5052   of command address) into 8 bit immediate value of LDI insn.  If the address
5053   is beyond the 128k boundary, the linker inserts a jump stub for this reloc
5054   below 128k.
5055 ENUM
5056   BFD_RELOC_AVR_HH8_LDI_PM
5057 ENUMDOC
5058   This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
5059   of command address) into 8 bit immediate value of LDI insn.
5060 ENUM
5061   BFD_RELOC_AVR_LO8_LDI_PM_NEG
5062 ENUMDOC
5063   This is a 16 bit reloc for the AVR that stores negated 8 bit value
5064   (usually command address) into 8 bit immediate value of SUBI insn.
5065 ENUM
5066   BFD_RELOC_AVR_HI8_LDI_PM_NEG
5067 ENUMDOC
5068   This is a 16 bit reloc for the AVR that stores negated 8 bit value
5069   (high 8 bit of 16 bit command address) into 8 bit immediate value
5070   of SUBI insn.
5071 ENUM
5072   BFD_RELOC_AVR_HH8_LDI_PM_NEG
5073 ENUMDOC
5074   This is a 16 bit reloc for the AVR that stores negated 8 bit value
5075   (high 6 bit of 22 bit command address) into 8 bit immediate
5076   value of SUBI insn.
5077 ENUM
5078   BFD_RELOC_AVR_CALL
5079 ENUMDOC
5080   This is a 32 bit reloc for the AVR that stores 23 bit value
5081   into 22 bits.
5082 ENUM
5083   BFD_RELOC_AVR_LDI
5084 ENUMDOC
5085   This is a 16 bit reloc for the AVR that stores all needed bits
5086   for absolute addressing with ldi with overflow check to linktime
5087 ENUM
5088   BFD_RELOC_AVR_6
5089 ENUMDOC
5090   This is a 6 bit reloc for the AVR that stores offset for ldd/std
5091   instructions
5092 ENUM
5093   BFD_RELOC_AVR_6_ADIW
5094 ENUMDOC
5095   This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw
5096   instructions
5097 ENUM
5098   BFD_RELOC_AVR_8_LO
5099 ENUMDOC
5100   This is a 8 bit reloc for the AVR that stores bits 0..7 of a symbol
5101   in .byte lo8(symbol)
5102 ENUM
5103   BFD_RELOC_AVR_8_HI
5104 ENUMDOC
5105   This is a 8 bit reloc for the AVR that stores bits 8..15 of a symbol
5106   in .byte hi8(symbol)
5107 ENUM
5108   BFD_RELOC_AVR_8_HLO
5109 ENUMDOC
5110   This is a 8 bit reloc for the AVR that stores bits 16..23 of a symbol
5111   in .byte hlo8(symbol)
5112 ENUM
5113   BFD_RELOC_AVR_DIFF8
5114 ENUMX
5115   BFD_RELOC_AVR_DIFF16
5116 ENUMX
5117   BFD_RELOC_AVR_DIFF32
5118 ENUMDOC
5119   AVR relocations to mark the difference of two local symbols.
5120   These are only needed to support linker relaxation and can be ignored
5121   when not relaxing.  The field is set to the value of the difference
5122   assuming no relaxation.  The relocation encodes the position of the
5123   second symbol so the linker can determine whether to adjust the field
5124   value.
5125 ENUM
5126   BFD_RELOC_AVR_LDS_STS_16
5127 ENUMDOC
5128   This is a 7 bit reloc for the AVR that stores SRAM address for 16bit
5129   lds and sts instructions supported only tiny core.
5130 ENUM
5131   BFD_RELOC_AVR_PORT6
5132 ENUMDOC
5133   This is a 6 bit reloc for the AVR that stores an I/O register
5134   number for the IN and OUT instructions
5135 ENUM
5136   BFD_RELOC_AVR_PORT5
5137 ENUMDOC
5138   This is a 5 bit reloc for the AVR that stores an I/O register
5139   number for the SBIC, SBIS, SBI and CBI instructions
5140
5141 ENUM
5142   BFD_RELOC_RISCV_HI20
5143 ENUMX
5144   BFD_RELOC_RISCV_PCREL_HI20
5145 ENUMX
5146   BFD_RELOC_RISCV_PCREL_LO12_I
5147 ENUMX
5148   BFD_RELOC_RISCV_PCREL_LO12_S
5149 ENUMX
5150   BFD_RELOC_RISCV_LO12_I
5151 ENUMX
5152   BFD_RELOC_RISCV_LO12_S
5153 ENUMX
5154   BFD_RELOC_RISCV_GPREL12_I
5155 ENUMX
5156   BFD_RELOC_RISCV_GPREL12_S
5157 ENUMX
5158   BFD_RELOC_RISCV_TPREL_HI20
5159 ENUMX
5160   BFD_RELOC_RISCV_TPREL_LO12_I
5161 ENUMX
5162   BFD_RELOC_RISCV_TPREL_LO12_S
5163 ENUMX
5164   BFD_RELOC_RISCV_TPREL_ADD
5165 ENUMX
5166   BFD_RELOC_RISCV_CALL
5167 ENUMX
5168   BFD_RELOC_RISCV_CALL_PLT
5169 ENUMX
5170   BFD_RELOC_RISCV_ADD8
5171 ENUMX
5172   BFD_RELOC_RISCV_ADD16
5173 ENUMX
5174   BFD_RELOC_RISCV_ADD32
5175 ENUMX
5176   BFD_RELOC_RISCV_ADD64
5177 ENUMX
5178   BFD_RELOC_RISCV_SUB8
5179 ENUMX
5180   BFD_RELOC_RISCV_SUB16
5181 ENUMX
5182   BFD_RELOC_RISCV_SUB32
5183 ENUMX
5184   BFD_RELOC_RISCV_SUB64
5185 ENUMX
5186   BFD_RELOC_RISCV_GOT_HI20
5187 ENUMX
5188   BFD_RELOC_RISCV_TLS_GOT_HI20
5189 ENUMX
5190   BFD_RELOC_RISCV_TLS_GD_HI20
5191 ENUMX
5192   BFD_RELOC_RISCV_JMP
5193 ENUMX
5194   BFD_RELOC_RISCV_TLS_DTPMOD32
5195 ENUMX
5196   BFD_RELOC_RISCV_TLS_DTPREL32
5197 ENUMX
5198   BFD_RELOC_RISCV_TLS_DTPMOD64
5199 ENUMX
5200   BFD_RELOC_RISCV_TLS_DTPREL64
5201 ENUMX
5202   BFD_RELOC_RISCV_TLS_TPREL32
5203 ENUMX
5204   BFD_RELOC_RISCV_TLS_TPREL64
5205 ENUMX
5206   BFD_RELOC_RISCV_ALIGN
5207 ENUMX
5208   BFD_RELOC_RISCV_RVC_BRANCH
5209 ENUMX
5210   BFD_RELOC_RISCV_RVC_JUMP
5211 ENUMX
5212   BFD_RELOC_RISCV_RVC_LUI
5213 ENUMX
5214   BFD_RELOC_RISCV_GPREL_I
5215 ENUMX
5216   BFD_RELOC_RISCV_GPREL_S
5217 ENUMX
5218   BFD_RELOC_RISCV_TPREL_I
5219 ENUMX
5220   BFD_RELOC_RISCV_TPREL_S
5221 ENUMX
5222   BFD_RELOC_RISCV_RELAX
5223 ENUMX
5224   BFD_RELOC_RISCV_CFA
5225 ENUMX
5226   BFD_RELOC_RISCV_SUB6
5227 ENUMX
5228   BFD_RELOC_RISCV_SET6
5229 ENUMX
5230   BFD_RELOC_RISCV_SET8
5231 ENUMX
5232   BFD_RELOC_RISCV_SET16
5233 ENUMX
5234   BFD_RELOC_RISCV_SET32
5235 ENUMX
5236   BFD_RELOC_RISCV_32_PCREL
5237 ENUMDOC
5238   RISC-V relocations.
5239
5240 ENUM
5241   BFD_RELOC_RL78_NEG8
5242 ENUMX
5243   BFD_RELOC_RL78_NEG16
5244 ENUMX
5245   BFD_RELOC_RL78_NEG24
5246 ENUMX
5247   BFD_RELOC_RL78_NEG32
5248 ENUMX
5249   BFD_RELOC_RL78_16_OP
5250 ENUMX
5251   BFD_RELOC_RL78_24_OP
5252 ENUMX
5253   BFD_RELOC_RL78_32_OP
5254 ENUMX
5255   BFD_RELOC_RL78_8U
5256 ENUMX
5257   BFD_RELOC_RL78_16U
5258 ENUMX
5259   BFD_RELOC_RL78_24U
5260 ENUMX
5261   BFD_RELOC_RL78_DIR3U_PCREL
5262 ENUMX
5263   BFD_RELOC_RL78_DIFF
5264 ENUMX
5265   BFD_RELOC_RL78_GPRELB
5266 ENUMX
5267   BFD_RELOC_RL78_GPRELW
5268 ENUMX
5269   BFD_RELOC_RL78_GPRELL
5270 ENUMX
5271   BFD_RELOC_RL78_SYM
5272 ENUMX
5273   BFD_RELOC_RL78_OP_SUBTRACT
5274 ENUMX
5275   BFD_RELOC_RL78_OP_NEG
5276 ENUMX
5277   BFD_RELOC_RL78_OP_AND
5278 ENUMX
5279   BFD_RELOC_RL78_OP_SHRA
5280 ENUMX
5281   BFD_RELOC_RL78_ABS8
5282 ENUMX
5283   BFD_RELOC_RL78_ABS16
5284 ENUMX
5285   BFD_RELOC_RL78_ABS16_REV
5286 ENUMX
5287   BFD_RELOC_RL78_ABS32
5288 ENUMX
5289   BFD_RELOC_RL78_ABS32_REV
5290 ENUMX
5291   BFD_RELOC_RL78_ABS16U
5292 ENUMX
5293   BFD_RELOC_RL78_ABS16UW
5294 ENUMX
5295   BFD_RELOC_RL78_ABS16UL
5296 ENUMX
5297   BFD_RELOC_RL78_RELAX
5298 ENUMX
5299   BFD_RELOC_RL78_HI16
5300 ENUMX
5301   BFD_RELOC_RL78_HI8
5302 ENUMX
5303   BFD_RELOC_RL78_LO16
5304 ENUMX
5305   BFD_RELOC_RL78_CODE
5306 ENUMX
5307   BFD_RELOC_RL78_SADDR
5308 ENUMDOC
5309   Renesas RL78 Relocations.
5310
5311 ENUM
5312   BFD_RELOC_RX_NEG8
5313 ENUMX
5314   BFD_RELOC_RX_NEG16
5315 ENUMX
5316   BFD_RELOC_RX_NEG24
5317 ENUMX
5318   BFD_RELOC_RX_NEG32
5319 ENUMX
5320   BFD_RELOC_RX_16_OP
5321 ENUMX
5322   BFD_RELOC_RX_24_OP
5323 ENUMX
5324   BFD_RELOC_RX_32_OP
5325 ENUMX
5326   BFD_RELOC_RX_8U
5327 ENUMX
5328   BFD_RELOC_RX_16U
5329 ENUMX
5330   BFD_RELOC_RX_24U
5331 ENUMX
5332   BFD_RELOC_RX_DIR3U_PCREL
5333 ENUMX
5334   BFD_RELOC_RX_DIFF
5335 ENUMX
5336   BFD_RELOC_RX_GPRELB
5337 ENUMX
5338   BFD_RELOC_RX_GPRELW
5339 ENUMX
5340   BFD_RELOC_RX_GPRELL
5341 ENUMX
5342   BFD_RELOC_RX_SYM
5343 ENUMX
5344   BFD_RELOC_RX_OP_SUBTRACT
5345 ENUMX
5346   BFD_RELOC_RX_OP_NEG
5347 ENUMX
5348   BFD_RELOC_RX_ABS8
5349 ENUMX
5350   BFD_RELOC_RX_ABS16
5351 ENUMX
5352   BFD_RELOC_RX_ABS16_REV
5353 ENUMX
5354   BFD_RELOC_RX_ABS32
5355 ENUMX
5356   BFD_RELOC_RX_ABS32_REV
5357 ENUMX
5358   BFD_RELOC_RX_ABS16U
5359 ENUMX
5360   BFD_RELOC_RX_ABS16UW
5361 ENUMX
5362   BFD_RELOC_RX_ABS16UL
5363 ENUMX
5364   BFD_RELOC_RX_RELAX
5365 ENUMDOC
5366   Renesas RX Relocations.
5367
5368 ENUM
5369   BFD_RELOC_390_12
5370 ENUMDOC
5371    Direct 12 bit.
5372 ENUM
5373   BFD_RELOC_390_GOT12
5374 ENUMDOC
5375   12 bit GOT offset.
5376 ENUM
5377   BFD_RELOC_390_PLT32
5378 ENUMDOC
5379   32 bit PC relative PLT address.
5380 ENUM
5381   BFD_RELOC_390_COPY
5382 ENUMDOC
5383   Copy symbol at runtime.
5384 ENUM
5385   BFD_RELOC_390_GLOB_DAT
5386 ENUMDOC
5387   Create GOT entry.
5388 ENUM
5389   BFD_RELOC_390_JMP_SLOT
5390 ENUMDOC
5391   Create PLT entry.
5392 ENUM
5393   BFD_RELOC_390_RELATIVE
5394 ENUMDOC
5395   Adjust by program base.
5396 ENUM
5397   BFD_RELOC_390_GOTPC
5398 ENUMDOC
5399   32 bit PC relative offset to GOT.
5400 ENUM
5401   BFD_RELOC_390_GOT16
5402 ENUMDOC
5403   16 bit GOT offset.
5404 ENUM
5405   BFD_RELOC_390_PC12DBL
5406 ENUMDOC
5407   PC relative 12 bit shifted by 1.
5408 ENUM
5409   BFD_RELOC_390_PLT12DBL
5410 ENUMDOC
5411   12 bit PC rel. PLT shifted by 1.
5412 ENUM
5413   BFD_RELOC_390_PC16DBL
5414 ENUMDOC
5415   PC relative 16 bit shifted by 1.
5416 ENUM
5417   BFD_RELOC_390_PLT16DBL
5418 ENUMDOC
5419   16 bit PC rel. PLT shifted by 1.
5420 ENUM
5421   BFD_RELOC_390_PC24DBL
5422 ENUMDOC
5423   PC relative 24 bit shifted by 1.
5424 ENUM
5425   BFD_RELOC_390_PLT24DBL
5426 ENUMDOC
5427   24 bit PC rel. PLT shifted by 1.
5428 ENUM
5429   BFD_RELOC_390_PC32DBL
5430 ENUMDOC
5431   PC relative 32 bit shifted by 1.
5432 ENUM
5433   BFD_RELOC_390_PLT32DBL
5434 ENUMDOC
5435   32 bit PC rel. PLT shifted by 1.
5436 ENUM
5437   BFD_RELOC_390_GOTPCDBL
5438 ENUMDOC
5439   32 bit PC rel. GOT shifted by 1.
5440 ENUM
5441   BFD_RELOC_390_GOT64
5442 ENUMDOC
5443   64 bit GOT offset.
5444 ENUM
5445   BFD_RELOC_390_PLT64
5446 ENUMDOC
5447   64 bit PC relative PLT address.
5448 ENUM
5449   BFD_RELOC_390_GOTENT
5450 ENUMDOC
5451   32 bit rel. offset to GOT entry.
5452 ENUM
5453   BFD_RELOC_390_GOTOFF64
5454 ENUMDOC
5455   64 bit offset to GOT.
5456 ENUM
5457   BFD_RELOC_390_GOTPLT12
5458 ENUMDOC
5459   12-bit offset to symbol-entry within GOT, with PLT handling.
5460 ENUM
5461   BFD_RELOC_390_GOTPLT16
5462 ENUMDOC
5463   16-bit offset to symbol-entry within GOT, with PLT handling.
5464 ENUM
5465   BFD_RELOC_390_GOTPLT32
5466 ENUMDOC
5467   32-bit offset to symbol-entry within GOT, with PLT handling.
5468 ENUM
5469   BFD_RELOC_390_GOTPLT64
5470 ENUMDOC
5471   64-bit offset to symbol-entry within GOT, with PLT handling.
5472 ENUM
5473   BFD_RELOC_390_GOTPLTENT
5474 ENUMDOC
5475   32-bit rel. offset to symbol-entry within GOT, with PLT handling.
5476 ENUM
5477   BFD_RELOC_390_PLTOFF16
5478 ENUMDOC
5479   16-bit rel. offset from the GOT to a PLT entry.
5480 ENUM
5481   BFD_RELOC_390_PLTOFF32
5482 ENUMDOC
5483   32-bit rel. offset from the GOT to a PLT entry.
5484 ENUM
5485   BFD_RELOC_390_PLTOFF64
5486 ENUMDOC
5487   64-bit rel. offset from the GOT to a PLT entry.
5488
5489 ENUM
5490   BFD_RELOC_390_TLS_LOAD
5491 ENUMX
5492   BFD_RELOC_390_TLS_GDCALL
5493 ENUMX
5494   BFD_RELOC_390_TLS_LDCALL
5495 ENUMX
5496   BFD_RELOC_390_TLS_GD32
5497 ENUMX
5498   BFD_RELOC_390_TLS_GD64
5499 ENUMX
5500   BFD_RELOC_390_TLS_GOTIE12
5501 ENUMX
5502   BFD_RELOC_390_TLS_GOTIE32
5503 ENUMX
5504   BFD_RELOC_390_TLS_GOTIE64
5505 ENUMX
5506   BFD_RELOC_390_TLS_LDM32
5507 ENUMX
5508   BFD_RELOC_390_TLS_LDM64
5509 ENUMX
5510   BFD_RELOC_390_TLS_IE32
5511 ENUMX
5512   BFD_RELOC_390_TLS_IE64
5513 ENUMX
5514   BFD_RELOC_390_TLS_IEENT
5515 ENUMX
5516   BFD_RELOC_390_TLS_LE32
5517 ENUMX
5518   BFD_RELOC_390_TLS_LE64
5519 ENUMX
5520   BFD_RELOC_390_TLS_LDO32
5521 ENUMX
5522   BFD_RELOC_390_TLS_LDO64
5523 ENUMX
5524   BFD_RELOC_390_TLS_DTPMOD
5525 ENUMX
5526   BFD_RELOC_390_TLS_DTPOFF
5527 ENUMX
5528   BFD_RELOC_390_TLS_TPOFF
5529 ENUMDOC
5530   s390 tls relocations.
5531
5532 ENUM
5533   BFD_RELOC_390_20
5534 ENUMX
5535   BFD_RELOC_390_GOT20
5536 ENUMX
5537   BFD_RELOC_390_GOTPLT20
5538 ENUMX
5539   BFD_RELOC_390_TLS_GOTIE20
5540 ENUMDOC
5541   Long displacement extension.
5542
5543 ENUM
5544   BFD_RELOC_390_IRELATIVE
5545 ENUMDOC
5546   STT_GNU_IFUNC relocation.
5547
5548 ENUM
5549   BFD_RELOC_SCORE_GPREL15
5550 ENUMDOC
5551   Score relocations
5552   Low 16 bit for load/store
5553 ENUM
5554   BFD_RELOC_SCORE_DUMMY2
5555 ENUMX
5556   BFD_RELOC_SCORE_JMP
5557 ENUMDOC
5558   This is a 24-bit reloc with the right 1 bit assumed to be 0
5559 ENUM
5560   BFD_RELOC_SCORE_BRANCH
5561 ENUMDOC
5562   This is a 19-bit reloc with the right 1 bit assumed to be 0
5563 ENUM
5564   BFD_RELOC_SCORE_IMM30
5565 ENUMDOC
5566   This is a 32-bit reloc for 48-bit instructions.
5567 ENUM
5568   BFD_RELOC_SCORE_IMM32
5569 ENUMDOC
5570   This is a 32-bit reloc for 48-bit instructions.
5571 ENUM
5572   BFD_RELOC_SCORE16_JMP
5573 ENUMDOC
5574   This is a 11-bit reloc with the right 1 bit assumed to be 0
5575 ENUM
5576   BFD_RELOC_SCORE16_BRANCH
5577 ENUMDOC
5578   This is a 8-bit reloc with the right 1 bit assumed to be 0
5579 ENUM
5580   BFD_RELOC_SCORE_BCMP
5581 ENUMDOC
5582    This is a 9-bit reloc with the right 1 bit assumed to be 0
5583 ENUM
5584   BFD_RELOC_SCORE_GOT15
5585 ENUMX
5586   BFD_RELOC_SCORE_GOT_LO16
5587 ENUMX
5588   BFD_RELOC_SCORE_CALL15
5589 ENUMX
5590   BFD_RELOC_SCORE_DUMMY_HI16
5591 ENUMDOC
5592   Undocumented Score relocs
5593
5594 ENUM
5595   BFD_RELOC_IP2K_FR9
5596 ENUMDOC
5597   Scenix IP2K - 9-bit register number / data address
5598 ENUM
5599   BFD_RELOC_IP2K_BANK
5600 ENUMDOC
5601   Scenix IP2K - 4-bit register/data bank number
5602 ENUM
5603   BFD_RELOC_IP2K_ADDR16CJP
5604 ENUMDOC
5605   Scenix IP2K - low 13 bits of instruction word address
5606 ENUM
5607   BFD_RELOC_IP2K_PAGE3
5608 ENUMDOC
5609   Scenix IP2K - high 3 bits of instruction word address
5610 ENUM
5611   BFD_RELOC_IP2K_LO8DATA
5612 ENUMX
5613   BFD_RELOC_IP2K_HI8DATA
5614 ENUMX
5615   BFD_RELOC_IP2K_EX8DATA
5616 ENUMDOC
5617   Scenix IP2K - ext/low/high 8 bits of data address
5618 ENUM
5619   BFD_RELOC_IP2K_LO8INSN
5620 ENUMX
5621   BFD_RELOC_IP2K_HI8INSN
5622 ENUMDOC
5623   Scenix IP2K - low/high 8 bits of instruction word address
5624 ENUM
5625   BFD_RELOC_IP2K_PC_SKIP
5626 ENUMDOC
5627   Scenix IP2K - even/odd PC modifier to modify snb pcl.0
5628 ENUM
5629   BFD_RELOC_IP2K_TEXT
5630 ENUMDOC
5631   Scenix IP2K - 16 bit word address in text section.
5632 ENUM
5633   BFD_RELOC_IP2K_FR_OFFSET
5634 ENUMDOC
5635   Scenix IP2K - 7-bit sp or dp offset
5636 ENUM
5637   BFD_RELOC_VPE4KMATH_DATA
5638 ENUMX
5639   BFD_RELOC_VPE4KMATH_INSN
5640 ENUMDOC
5641   Scenix VPE4K coprocessor - data/insn-space addressing
5642
5643 ENUM
5644   BFD_RELOC_VTABLE_INHERIT
5645 ENUMX
5646   BFD_RELOC_VTABLE_ENTRY
5647 ENUMDOC
5648   These two relocations are used by the linker to determine which of
5649   the entries in a C++ virtual function table are actually used.  When
5650   the --gc-sections option is given, the linker will zero out the entries
5651   that are not used, so that the code for those functions need not be
5652   included in the output.
5653
5654   VTABLE_INHERIT is a zero-space relocation used to describe to the
5655   linker the inheritance tree of a C++ virtual function table.  The
5656   relocation's symbol should be the parent class' vtable, and the
5657   relocation should be located at the child vtable.
5658
5659   VTABLE_ENTRY is a zero-space relocation that describes the use of a
5660   virtual function table entry.  The reloc's symbol should refer to the
5661   table of the class mentioned in the code.  Off of that base, an offset
5662   describes the entry that is being used.  For Rela hosts, this offset
5663   is stored in the reloc's addend.  For Rel hosts, we are forced to put
5664   this offset in the reloc's section offset.
5665
5666 ENUM
5667   BFD_RELOC_IA64_IMM14
5668 ENUMX
5669   BFD_RELOC_IA64_IMM22
5670 ENUMX
5671   BFD_RELOC_IA64_IMM64
5672 ENUMX
5673   BFD_RELOC_IA64_DIR32MSB
5674 ENUMX
5675   BFD_RELOC_IA64_DIR32LSB
5676 ENUMX
5677   BFD_RELOC_IA64_DIR64MSB
5678 ENUMX
5679   BFD_RELOC_IA64_DIR64LSB
5680 ENUMX
5681   BFD_RELOC_IA64_GPREL22
5682 ENUMX
5683   BFD_RELOC_IA64_GPREL64I
5684 ENUMX
5685   BFD_RELOC_IA64_GPREL32MSB
5686 ENUMX
5687   BFD_RELOC_IA64_GPREL32LSB
5688 ENUMX
5689   BFD_RELOC_IA64_GPREL64MSB
5690 ENUMX
5691   BFD_RELOC_IA64_GPREL64LSB
5692 ENUMX
5693   BFD_RELOC_IA64_LTOFF22
5694 ENUMX
5695   BFD_RELOC_IA64_LTOFF64I
5696 ENUMX
5697   BFD_RELOC_IA64_PLTOFF22
5698 ENUMX
5699   BFD_RELOC_IA64_PLTOFF64I
5700 ENUMX
5701   BFD_RELOC_IA64_PLTOFF64MSB
5702 ENUMX
5703   BFD_RELOC_IA64_PLTOFF64LSB
5704 ENUMX
5705   BFD_RELOC_IA64_FPTR64I
5706 ENUMX
5707   BFD_RELOC_IA64_FPTR32MSB
5708 ENUMX
5709   BFD_RELOC_IA64_FPTR32LSB
5710 ENUMX
5711   BFD_RELOC_IA64_FPTR64MSB
5712 ENUMX
5713   BFD_RELOC_IA64_FPTR64LSB
5714 ENUMX
5715   BFD_RELOC_IA64_PCREL21B
5716 ENUMX
5717   BFD_RELOC_IA64_PCREL21BI
5718 ENUMX
5719   BFD_RELOC_IA64_PCREL21M
5720 ENUMX
5721   BFD_RELOC_IA64_PCREL21F
5722 ENUMX
5723   BFD_RELOC_IA64_PCREL22
5724 ENUMX
5725   BFD_RELOC_IA64_PCREL60B
5726 ENUMX
5727   BFD_RELOC_IA64_PCREL64I
5728 ENUMX
5729   BFD_RELOC_IA64_PCREL32MSB
5730 ENUMX
5731   BFD_RELOC_IA64_PCREL32LSB
5732 ENUMX
5733   BFD_RELOC_IA64_PCREL64MSB
5734 ENUMX
5735   BFD_RELOC_IA64_PCREL64LSB
5736 ENUMX
5737   BFD_RELOC_IA64_LTOFF_FPTR22
5738 ENUMX
5739   BFD_RELOC_IA64_LTOFF_FPTR64I
5740 ENUMX
5741   BFD_RELOC_IA64_LTOFF_FPTR32MSB
5742 ENUMX
5743   BFD_RELOC_IA64_LTOFF_FPTR32LSB
5744 ENUMX
5745   BFD_RELOC_IA64_LTOFF_FPTR64MSB
5746 ENUMX
5747   BFD_RELOC_IA64_LTOFF_FPTR64LSB
5748 ENUMX
5749   BFD_RELOC_IA64_SEGREL32MSB
5750 ENUMX
5751   BFD_RELOC_IA64_SEGREL32LSB
5752 ENUMX
5753   BFD_RELOC_IA64_SEGREL64MSB
5754 ENUMX
5755   BFD_RELOC_IA64_SEGREL64LSB
5756 ENUMX
5757   BFD_RELOC_IA64_SECREL32MSB
5758 ENUMX
5759   BFD_RELOC_IA64_SECREL32LSB
5760 ENUMX
5761   BFD_RELOC_IA64_SECREL64MSB
5762 ENUMX
5763   BFD_RELOC_IA64_SECREL64LSB
5764 ENUMX
5765   BFD_RELOC_IA64_REL32MSB
5766 ENUMX
5767   BFD_RELOC_IA64_REL32LSB
5768 ENUMX
5769   BFD_RELOC_IA64_REL64MSB
5770 ENUMX
5771   BFD_RELOC_IA64_REL64LSB
5772 ENUMX
5773   BFD_RELOC_IA64_LTV32MSB
5774 ENUMX
5775   BFD_RELOC_IA64_LTV32LSB
5776 ENUMX
5777   BFD_RELOC_IA64_LTV64MSB
5778 ENUMX
5779   BFD_RELOC_IA64_LTV64LSB
5780 ENUMX
5781   BFD_RELOC_IA64_IPLTMSB
5782 ENUMX
5783   BFD_RELOC_IA64_IPLTLSB
5784 ENUMX
5785   BFD_RELOC_IA64_COPY
5786 ENUMX
5787   BFD_RELOC_IA64_LTOFF22X
5788 ENUMX
5789   BFD_RELOC_IA64_LDXMOV
5790 ENUMX
5791   BFD_RELOC_IA64_TPREL14
5792 ENUMX
5793   BFD_RELOC_IA64_TPREL22
5794 ENUMX
5795   BFD_RELOC_IA64_TPREL64I
5796 ENUMX
5797   BFD_RELOC_IA64_TPREL64MSB
5798 ENUMX
5799   BFD_RELOC_IA64_TPREL64LSB
5800 ENUMX
5801   BFD_RELOC_IA64_LTOFF_TPREL22
5802 ENUMX
5803   BFD_RELOC_IA64_DTPMOD64MSB
5804 ENUMX
5805   BFD_RELOC_IA64_DTPMOD64LSB
5806 ENUMX
5807   BFD_RELOC_IA64_LTOFF_DTPMOD22
5808 ENUMX
5809   BFD_RELOC_IA64_DTPREL14
5810 ENUMX
5811   BFD_RELOC_IA64_DTPREL22
5812 ENUMX
5813   BFD_RELOC_IA64_DTPREL64I
5814 ENUMX
5815   BFD_RELOC_IA64_DTPREL32MSB
5816 ENUMX
5817   BFD_RELOC_IA64_DTPREL32LSB
5818 ENUMX
5819   BFD_RELOC_IA64_DTPREL64MSB
5820 ENUMX
5821   BFD_RELOC_IA64_DTPREL64LSB
5822 ENUMX
5823   BFD_RELOC_IA64_LTOFF_DTPREL22
5824 ENUMDOC
5825   Intel IA64 Relocations.
5826
5827 ENUM
5828   BFD_RELOC_M68HC11_HI8
5829 ENUMDOC
5830   Motorola 68HC11 reloc.
5831   This is the 8 bit high part of an absolute address.
5832 ENUM
5833   BFD_RELOC_M68HC11_LO8
5834 ENUMDOC
5835   Motorola 68HC11 reloc.
5836   This is the 8 bit low part of an absolute address.
5837 ENUM
5838   BFD_RELOC_M68HC11_3B
5839 ENUMDOC
5840   Motorola 68HC11 reloc.
5841   This is the 3 bit of a value.
5842 ENUM
5843   BFD_RELOC_M68HC11_RL_JUMP
5844 ENUMDOC
5845   Motorola 68HC11 reloc.
5846   This reloc marks the beginning of a jump/call instruction.
5847   It is used for linker relaxation to correctly identify beginning
5848   of instruction and change some branches to use PC-relative
5849   addressing mode.
5850 ENUM
5851   BFD_RELOC_M68HC11_RL_GROUP
5852 ENUMDOC
5853   Motorola 68HC11 reloc.
5854   This reloc marks a group of several instructions that gcc generates
5855   and for which the linker relaxation pass can modify and/or remove
5856   some of them.
5857 ENUM
5858   BFD_RELOC_M68HC11_LO16
5859 ENUMDOC
5860   Motorola 68HC11 reloc.
5861   This is the 16-bit lower part of an address.  It is used for 'call'
5862   instruction to specify the symbol address without any special
5863   transformation (due to memory bank window).
5864 ENUM
5865   BFD_RELOC_M68HC11_PAGE
5866 ENUMDOC
5867   Motorola 68HC11 reloc.
5868   This is a 8-bit reloc that specifies the page number of an address.
5869   It is used by 'call' instruction to specify the page number of
5870   the symbol.
5871 ENUM
5872   BFD_RELOC_M68HC11_24
5873 ENUMDOC
5874   Motorola 68HC11 reloc.
5875   This is a 24-bit reloc that represents the address with a 16-bit
5876   value and a 8-bit page number.  The symbol address is transformed
5877   to follow the 16K memory bank of 68HC12 (seen as mapped in the window).
5878 ENUM
5879   BFD_RELOC_M68HC12_5B
5880 ENUMDOC
5881   Motorola 68HC12 reloc.
5882   This is the 5 bits of a value.
5883 ENUM
5884   BFD_RELOC_XGATE_RL_JUMP
5885 ENUMDOC
5886   Freescale XGATE reloc.
5887   This reloc marks the beginning of a bra/jal instruction.
5888 ENUM
5889   BFD_RELOC_XGATE_RL_GROUP
5890 ENUMDOC
5891   Freescale XGATE reloc.
5892   This reloc marks a group of several instructions that gcc generates
5893   and for which the linker relaxation pass can modify and/or remove
5894   some of them.
5895 ENUM
5896   BFD_RELOC_XGATE_LO16
5897 ENUMDOC
5898   Freescale XGATE reloc.
5899   This is the 16-bit lower part of an address.  It is used for the '16-bit'
5900   instructions.
5901 ENUM
5902   BFD_RELOC_XGATE_GPAGE
5903 ENUMDOC
5904   Freescale XGATE reloc.
5905 ENUM
5906   BFD_RELOC_XGATE_24
5907 ENUMDOC
5908   Freescale XGATE reloc.
5909 ENUM
5910   BFD_RELOC_XGATE_PCREL_9
5911 ENUMDOC
5912   Freescale XGATE reloc.
5913   This is a 9-bit pc-relative reloc.
5914 ENUM
5915   BFD_RELOC_XGATE_PCREL_10
5916 ENUMDOC
5917   Freescale XGATE reloc.
5918   This is a 10-bit pc-relative reloc.
5919 ENUM
5920   BFD_RELOC_XGATE_IMM8_LO
5921 ENUMDOC
5922   Freescale XGATE reloc.
5923   This is the 16-bit lower part of an address.  It is used for the '16-bit'
5924   instructions.
5925 ENUM
5926   BFD_RELOC_XGATE_IMM8_HI
5927 ENUMDOC
5928   Freescale XGATE reloc.
5929   This is the 16-bit higher part of an address.  It is used for the '16-bit'
5930   instructions.
5931 ENUM
5932   BFD_RELOC_XGATE_IMM3
5933 ENUMDOC
5934   Freescale XGATE reloc.
5935   This is a 3-bit pc-relative reloc.
5936 ENUM
5937   BFD_RELOC_XGATE_IMM4
5938 ENUMDOC
5939   Freescale XGATE reloc.
5940   This is a 4-bit pc-relative reloc.
5941 ENUM
5942   BFD_RELOC_XGATE_IMM5
5943 ENUMDOC
5944   Freescale XGATE reloc.
5945   This is a 5-bit pc-relative reloc.
5946 ENUM
5947   BFD_RELOC_M68HC12_9B
5948 ENUMDOC
5949   Motorola 68HC12 reloc.
5950   This is the 9 bits of a value.
5951 ENUM
5952   BFD_RELOC_M68HC12_16B
5953 ENUMDOC
5954   Motorola 68HC12 reloc.
5955   This is the 16 bits of a value.
5956 ENUM
5957   BFD_RELOC_M68HC12_9_PCREL
5958 ENUMDOC
5959   Motorola 68HC12/XGATE reloc.
5960   This is a PCREL9 branch.
5961 ENUM
5962   BFD_RELOC_M68HC12_10_PCREL
5963 ENUMDOC
5964   Motorola 68HC12/XGATE reloc.
5965   This is a PCREL10 branch.
5966 ENUM
5967   BFD_RELOC_M68HC12_LO8XG
5968 ENUMDOC
5969   Motorola 68HC12/XGATE reloc.
5970   This is the 8 bit low part of an absolute address and immediately precedes
5971   a matching HI8XG part.
5972 ENUM
5973   BFD_RELOC_M68HC12_HI8XG
5974 ENUMDOC
5975   Motorola 68HC12/XGATE reloc.
5976   This is the 8 bit high part of an absolute address and immediately follows
5977   a matching LO8XG part.
5978 ENUM
5979   BFD_RELOC_S12Z_15_PCREL
5980 ENUMDOC
5981   Freescale S12Z reloc.
5982   This is a 15 bit relative address.  If the most significant bits are all zero
5983   then it may be truncated to 8 bits.
5984
5985 ENUM
5986   BFD_RELOC_CR16_NUM8
5987 ENUMX
5988   BFD_RELOC_CR16_NUM16
5989 ENUMX
5990   BFD_RELOC_CR16_NUM32
5991 ENUMX
5992   BFD_RELOC_CR16_NUM32a
5993 ENUMX
5994   BFD_RELOC_CR16_REGREL0
5995 ENUMX
5996   BFD_RELOC_CR16_REGREL4
5997 ENUMX
5998   BFD_RELOC_CR16_REGREL4a
5999 ENUMX
6000   BFD_RELOC_CR16_REGREL14
6001 ENUMX
6002   BFD_RELOC_CR16_REGREL14a
6003 ENUMX
6004   BFD_RELOC_CR16_REGREL16
6005 ENUMX
6006   BFD_RELOC_CR16_REGREL20
6007 ENUMX
6008   BFD_RELOC_CR16_REGREL20a
6009 ENUMX
6010   BFD_RELOC_CR16_ABS20
6011 ENUMX
6012   BFD_RELOC_CR16_ABS24
6013 ENUMX
6014   BFD_RELOC_CR16_IMM4
6015 ENUMX
6016   BFD_RELOC_CR16_IMM8
6017 ENUMX
6018   BFD_RELOC_CR16_IMM16
6019 ENUMX
6020   BFD_RELOC_CR16_IMM20
6021 ENUMX
6022   BFD_RELOC_CR16_IMM24
6023 ENUMX
6024   BFD_RELOC_CR16_IMM32
6025 ENUMX
6026   BFD_RELOC_CR16_IMM32a
6027 ENUMX
6028   BFD_RELOC_CR16_DISP4
6029 ENUMX
6030   BFD_RELOC_CR16_DISP8
6031 ENUMX
6032   BFD_RELOC_CR16_DISP16
6033 ENUMX
6034   BFD_RELOC_CR16_DISP20
6035 ENUMX
6036   BFD_RELOC_CR16_DISP24
6037 ENUMX
6038   BFD_RELOC_CR16_DISP24a
6039 ENUMX
6040   BFD_RELOC_CR16_SWITCH8
6041 ENUMX
6042   BFD_RELOC_CR16_SWITCH16
6043 ENUMX
6044   BFD_RELOC_CR16_SWITCH32
6045 ENUMX
6046   BFD_RELOC_CR16_GOT_REGREL20
6047 ENUMX
6048   BFD_RELOC_CR16_GOTC_REGREL20
6049 ENUMX
6050   BFD_RELOC_CR16_GLOB_DAT
6051 ENUMDOC
6052   NS CR16 Relocations.
6053
6054 ENUM
6055   BFD_RELOC_CRX_REL4
6056 ENUMX
6057   BFD_RELOC_CRX_REL8
6058 ENUMX
6059   BFD_RELOC_CRX_REL8_CMP
6060 ENUMX
6061   BFD_RELOC_CRX_REL16
6062 ENUMX
6063   BFD_RELOC_CRX_REL24
6064 ENUMX
6065   BFD_RELOC_CRX_REL32
6066 ENUMX
6067   BFD_RELOC_CRX_REGREL12
6068 ENUMX
6069   BFD_RELOC_CRX_REGREL22
6070 ENUMX
6071   BFD_RELOC_CRX_REGREL28
6072 ENUMX
6073   BFD_RELOC_CRX_REGREL32
6074 ENUMX
6075   BFD_RELOC_CRX_ABS16
6076 ENUMX
6077   BFD_RELOC_CRX_ABS32
6078 ENUMX
6079   BFD_RELOC_CRX_NUM8
6080 ENUMX
6081   BFD_RELOC_CRX_NUM16
6082 ENUMX
6083   BFD_RELOC_CRX_NUM32
6084 ENUMX
6085   BFD_RELOC_CRX_IMM16
6086 ENUMX
6087   BFD_RELOC_CRX_IMM32
6088 ENUMX
6089   BFD_RELOC_CRX_SWITCH8
6090 ENUMX
6091   BFD_RELOC_CRX_SWITCH16
6092 ENUMX
6093   BFD_RELOC_CRX_SWITCH32
6094 ENUMDOC
6095   NS CRX Relocations.
6096
6097 ENUM
6098   BFD_RELOC_CRIS_BDISP8
6099 ENUMX
6100   BFD_RELOC_CRIS_UNSIGNED_5
6101 ENUMX
6102   BFD_RELOC_CRIS_SIGNED_6
6103 ENUMX
6104   BFD_RELOC_CRIS_UNSIGNED_6
6105 ENUMX
6106   BFD_RELOC_CRIS_SIGNED_8
6107 ENUMX
6108   BFD_RELOC_CRIS_UNSIGNED_8
6109 ENUMX
6110   BFD_RELOC_CRIS_SIGNED_16
6111 ENUMX
6112   BFD_RELOC_CRIS_UNSIGNED_16
6113 ENUMX
6114   BFD_RELOC_CRIS_LAPCQ_OFFSET
6115 ENUMX
6116   BFD_RELOC_CRIS_UNSIGNED_4
6117 ENUMDOC
6118   These relocs are only used within the CRIS assembler.  They are not
6119   (at present) written to any object files.
6120 ENUM
6121   BFD_RELOC_CRIS_COPY
6122 ENUMX
6123   BFD_RELOC_CRIS_GLOB_DAT
6124 ENUMX
6125   BFD_RELOC_CRIS_JUMP_SLOT
6126 ENUMX
6127   BFD_RELOC_CRIS_RELATIVE
6128 ENUMDOC
6129   Relocs used in ELF shared libraries for CRIS.
6130 ENUM
6131   BFD_RELOC_CRIS_32_GOT
6132 ENUMDOC
6133   32-bit offset to symbol-entry within GOT.
6134 ENUM
6135   BFD_RELOC_CRIS_16_GOT
6136 ENUMDOC
6137   16-bit offset to symbol-entry within GOT.
6138 ENUM
6139   BFD_RELOC_CRIS_32_GOTPLT
6140 ENUMDOC
6141   32-bit offset to symbol-entry within GOT, with PLT handling.
6142 ENUM
6143   BFD_RELOC_CRIS_16_GOTPLT
6144 ENUMDOC
6145   16-bit offset to symbol-entry within GOT, with PLT handling.
6146 ENUM
6147   BFD_RELOC_CRIS_32_GOTREL
6148 ENUMDOC
6149   32-bit offset to symbol, relative to GOT.
6150 ENUM
6151   BFD_RELOC_CRIS_32_PLT_GOTREL
6152 ENUMDOC
6153   32-bit offset to symbol with PLT entry, relative to GOT.
6154 ENUM
6155   BFD_RELOC_CRIS_32_PLT_PCREL
6156 ENUMDOC
6157   32-bit offset to symbol with PLT entry, relative to this relocation.
6158
6159 ENUM
6160   BFD_RELOC_CRIS_32_GOT_GD
6161 ENUMX
6162   BFD_RELOC_CRIS_16_GOT_GD
6163 ENUMX
6164   BFD_RELOC_CRIS_32_GD
6165 ENUMX
6166   BFD_RELOC_CRIS_DTP
6167 ENUMX
6168   BFD_RELOC_CRIS_32_DTPREL
6169 ENUMX
6170   BFD_RELOC_CRIS_16_DTPREL
6171 ENUMX
6172   BFD_RELOC_CRIS_32_GOT_TPREL
6173 ENUMX
6174   BFD_RELOC_CRIS_16_GOT_TPREL
6175 ENUMX
6176   BFD_RELOC_CRIS_32_TPREL
6177 ENUMX
6178   BFD_RELOC_CRIS_16_TPREL
6179 ENUMX
6180   BFD_RELOC_CRIS_DTPMOD
6181 ENUMX
6182   BFD_RELOC_CRIS_32_IE
6183 ENUMDOC
6184   Relocs used in TLS code for CRIS.
6185
6186 ENUM
6187   BFD_RELOC_OR1K_REL_26
6188 ENUMX
6189   BFD_RELOC_OR1K_SLO16
6190 ENUMX
6191   BFD_RELOC_OR1K_PCREL_PG21
6192 ENUMX
6193   BFD_RELOC_OR1K_LO13
6194 ENUMX
6195   BFD_RELOC_OR1K_SLO13
6196 ENUMX
6197   BFD_RELOC_OR1K_GOTPC_HI16
6198 ENUMX
6199   BFD_RELOC_OR1K_GOTPC_LO16
6200 ENUMX
6201   BFD_RELOC_OR1K_GOT16
6202 ENUMX
6203   BFD_RELOC_OR1K_GOT_PG21
6204 ENUMX
6205   BFD_RELOC_OR1K_GOT_LO13
6206 ENUMX
6207   BFD_RELOC_OR1K_PLT26
6208 ENUMX
6209   BFD_RELOC_OR1K_PLTA26
6210 ENUMX
6211   BFD_RELOC_OR1K_GOTOFF_SLO16
6212 ENUMX
6213   BFD_RELOC_OR1K_COPY
6214 ENUMX
6215   BFD_RELOC_OR1K_GLOB_DAT
6216 ENUMX
6217   BFD_RELOC_OR1K_JMP_SLOT
6218 ENUMX
6219   BFD_RELOC_OR1K_RELATIVE
6220 ENUMX
6221   BFD_RELOC_OR1K_TLS_GD_HI16
6222 ENUMX
6223   BFD_RELOC_OR1K_TLS_GD_LO16
6224 ENUMX
6225   BFD_RELOC_OR1K_TLS_GD_PG21
6226 ENUMX
6227   BFD_RELOC_OR1K_TLS_GD_LO13
6228 ENUMX
6229   BFD_RELOC_OR1K_TLS_LDM_HI16
6230 ENUMX
6231   BFD_RELOC_OR1K_TLS_LDM_LO16
6232 ENUMX
6233   BFD_RELOC_OR1K_TLS_LDM_PG21
6234 ENUMX
6235   BFD_RELOC_OR1K_TLS_LDM_LO13
6236 ENUMX
6237   BFD_RELOC_OR1K_TLS_LDO_HI16
6238 ENUMX
6239   BFD_RELOC_OR1K_TLS_LDO_LO16
6240 ENUMX
6241   BFD_RELOC_OR1K_TLS_IE_HI16
6242 ENUMX
6243   BFD_RELOC_OR1K_TLS_IE_AHI16
6244 ENUMX
6245   BFD_RELOC_OR1K_TLS_IE_LO16
6246 ENUMX
6247   BFD_RELOC_OR1K_TLS_IE_PG21
6248 ENUMX
6249   BFD_RELOC_OR1K_TLS_IE_LO13
6250 ENUMX
6251   BFD_RELOC_OR1K_TLS_LE_HI16
6252 ENUMX
6253   BFD_RELOC_OR1K_TLS_LE_AHI16
6254 ENUMX
6255   BFD_RELOC_OR1K_TLS_LE_LO16
6256 ENUMX
6257   BFD_RELOC_OR1K_TLS_LE_SLO16
6258 ENUMX
6259   BFD_RELOC_OR1K_TLS_TPOFF
6260 ENUMX
6261   BFD_RELOC_OR1K_TLS_DTPOFF
6262 ENUMX
6263   BFD_RELOC_OR1K_TLS_DTPMOD
6264 ENUMDOC
6265   OpenRISC 1000 Relocations.
6266
6267 ENUM
6268   BFD_RELOC_H8_DIR16A8
6269 ENUMX
6270   BFD_RELOC_H8_DIR16R8
6271 ENUMX
6272   BFD_RELOC_H8_DIR24A8
6273 ENUMX
6274   BFD_RELOC_H8_DIR24R8
6275 ENUMX
6276   BFD_RELOC_H8_DIR32A16
6277 ENUMX
6278   BFD_RELOC_H8_DISP32A16
6279 ENUMDOC
6280   H8 elf Relocations.
6281
6282 ENUM
6283   BFD_RELOC_XSTORMY16_REL_12
6284 ENUMX
6285   BFD_RELOC_XSTORMY16_12
6286 ENUMX
6287   BFD_RELOC_XSTORMY16_24
6288 ENUMX
6289   BFD_RELOC_XSTORMY16_FPTR16
6290 ENUMDOC
6291   Sony Xstormy16 Relocations.
6292
6293 ENUM
6294   BFD_RELOC_RELC
6295 ENUMDOC
6296   Self-describing complex relocations.
6297 COMMENT
6298
6299 ENUM
6300   BFD_RELOC_XC16X_PAG
6301 ENUMX
6302   BFD_RELOC_XC16X_POF
6303 ENUMX
6304   BFD_RELOC_XC16X_SEG
6305 ENUMX
6306   BFD_RELOC_XC16X_SOF
6307 ENUMDOC
6308   Infineon Relocations.
6309
6310 ENUM
6311   BFD_RELOC_VAX_GLOB_DAT
6312 ENUMX
6313   BFD_RELOC_VAX_JMP_SLOT
6314 ENUMX
6315   BFD_RELOC_VAX_RELATIVE
6316 ENUMDOC
6317   Relocations used by VAX ELF.
6318
6319 ENUM
6320   BFD_RELOC_MT_PC16
6321 ENUMDOC
6322   Morpho MT - 16 bit immediate relocation.
6323 ENUM
6324   BFD_RELOC_MT_HI16
6325 ENUMDOC
6326   Morpho MT - Hi 16 bits of an address.
6327 ENUM
6328   BFD_RELOC_MT_LO16
6329 ENUMDOC
6330   Morpho MT - Low 16 bits of an address.
6331 ENUM
6332   BFD_RELOC_MT_GNU_VTINHERIT
6333 ENUMDOC
6334   Morpho MT - Used to tell the linker which vtable entries are used.
6335 ENUM
6336   BFD_RELOC_MT_GNU_VTENTRY
6337 ENUMDOC
6338   Morpho MT - Used to tell the linker which vtable entries are used.
6339 ENUM
6340   BFD_RELOC_MT_PCINSN8
6341 ENUMDOC
6342   Morpho MT - 8 bit immediate relocation.
6343
6344 ENUM
6345   BFD_RELOC_MSP430_10_PCREL
6346 ENUMX
6347   BFD_RELOC_MSP430_16_PCREL
6348 ENUMX
6349   BFD_RELOC_MSP430_16
6350 ENUMX
6351   BFD_RELOC_MSP430_16_PCREL_BYTE
6352 ENUMX
6353   BFD_RELOC_MSP430_16_BYTE
6354 ENUMX
6355   BFD_RELOC_MSP430_2X_PCREL
6356 ENUMX
6357   BFD_RELOC_MSP430_RL_PCREL
6358 ENUMX
6359   BFD_RELOC_MSP430_ABS8
6360 ENUMX
6361   BFD_RELOC_MSP430X_PCR20_EXT_SRC
6362 ENUMX
6363   BFD_RELOC_MSP430X_PCR20_EXT_DST
6364 ENUMX
6365   BFD_RELOC_MSP430X_PCR20_EXT_ODST
6366 ENUMX
6367   BFD_RELOC_MSP430X_ABS20_EXT_SRC
6368 ENUMX
6369   BFD_RELOC_MSP430X_ABS20_EXT_DST
6370 ENUMX
6371   BFD_RELOC_MSP430X_ABS20_EXT_ODST
6372 ENUMX
6373   BFD_RELOC_MSP430X_ABS20_ADR_SRC
6374 ENUMX
6375   BFD_RELOC_MSP430X_ABS20_ADR_DST
6376 ENUMX
6377   BFD_RELOC_MSP430X_PCR16
6378 ENUMX
6379   BFD_RELOC_MSP430X_PCR20_CALL
6380 ENUMX
6381   BFD_RELOC_MSP430X_ABS16
6382 ENUMX
6383   BFD_RELOC_MSP430_ABS_HI16
6384 ENUMX
6385   BFD_RELOC_MSP430_PREL31
6386 ENUMX
6387   BFD_RELOC_MSP430_SYM_DIFF
6388 ENUMX
6389   BFD_RELOC_MSP430_SET_ULEB128
6390 ENUMX
6391   BFD_RELOC_MSP430_SUB_ULEB128
6392
6393 ENUMDOC
6394   msp430 specific relocation codes
6395
6396 ENUM
6397   BFD_RELOC_NIOS2_S16
6398 ENUMX
6399   BFD_RELOC_NIOS2_U16
6400 ENUMX
6401   BFD_RELOC_NIOS2_CALL26
6402 ENUMX
6403   BFD_RELOC_NIOS2_IMM5
6404 ENUMX
6405   BFD_RELOC_NIOS2_CACHE_OPX
6406 ENUMX
6407   BFD_RELOC_NIOS2_IMM6
6408 ENUMX
6409   BFD_RELOC_NIOS2_IMM8
6410 ENUMX
6411   BFD_RELOC_NIOS2_HI16
6412 ENUMX
6413   BFD_RELOC_NIOS2_LO16
6414 ENUMX
6415   BFD_RELOC_NIOS2_HIADJ16
6416 ENUMX
6417   BFD_RELOC_NIOS2_GPREL
6418 ENUMX
6419   BFD_RELOC_NIOS2_UJMP
6420 ENUMX
6421   BFD_RELOC_NIOS2_CJMP
6422 ENUMX
6423   BFD_RELOC_NIOS2_CALLR
6424 ENUMX
6425   BFD_RELOC_NIOS2_ALIGN
6426 ENUMX
6427   BFD_RELOC_NIOS2_GOT16
6428 ENUMX
6429   BFD_RELOC_NIOS2_CALL16
6430 ENUMX
6431   BFD_RELOC_NIOS2_GOTOFF_LO
6432 ENUMX
6433   BFD_RELOC_NIOS2_GOTOFF_HA
6434 ENUMX
6435   BFD_RELOC_NIOS2_PCREL_LO
6436 ENUMX
6437   BFD_RELOC_NIOS2_PCREL_HA
6438 ENUMX
6439   BFD_RELOC_NIOS2_TLS_GD16
6440 ENUMX
6441   BFD_RELOC_NIOS2_TLS_LDM16
6442 ENUMX
6443   BFD_RELOC_NIOS2_TLS_LDO16
6444 ENUMX
6445   BFD_RELOC_NIOS2_TLS_IE16
6446 ENUMX
6447   BFD_RELOC_NIOS2_TLS_LE16
6448 ENUMX
6449   BFD_RELOC_NIOS2_TLS_DTPMOD
6450 ENUMX
6451   BFD_RELOC_NIOS2_TLS_DTPREL
6452 ENUMX
6453   BFD_RELOC_NIOS2_TLS_TPREL
6454 ENUMX
6455   BFD_RELOC_NIOS2_COPY
6456 ENUMX
6457   BFD_RELOC_NIOS2_GLOB_DAT
6458 ENUMX
6459   BFD_RELOC_NIOS2_JUMP_SLOT
6460 ENUMX
6461   BFD_RELOC_NIOS2_RELATIVE
6462 ENUMX
6463   BFD_RELOC_NIOS2_GOTOFF
6464 ENUMX
6465   BFD_RELOC_NIOS2_CALL26_NOAT
6466 ENUMX
6467   BFD_RELOC_NIOS2_GOT_LO
6468 ENUMX
6469   BFD_RELOC_NIOS2_GOT_HA
6470 ENUMX
6471   BFD_RELOC_NIOS2_CALL_LO
6472 ENUMX
6473   BFD_RELOC_NIOS2_CALL_HA
6474 ENUMX
6475   BFD_RELOC_NIOS2_R2_S12
6476 ENUMX
6477   BFD_RELOC_NIOS2_R2_I10_1_PCREL
6478 ENUMX
6479   BFD_RELOC_NIOS2_R2_T1I7_1_PCREL
6480 ENUMX
6481   BFD_RELOC_NIOS2_R2_T1I7_2
6482 ENUMX
6483   BFD_RELOC_NIOS2_R2_T2I4
6484 ENUMX
6485   BFD_RELOC_NIOS2_R2_T2I4_1
6486 ENUMX
6487   BFD_RELOC_NIOS2_R2_T2I4_2
6488 ENUMX
6489   BFD_RELOC_NIOS2_R2_X1I7_2
6490 ENUMX
6491   BFD_RELOC_NIOS2_R2_X2L5
6492 ENUMX
6493   BFD_RELOC_NIOS2_R2_F1I5_2
6494 ENUMX
6495   BFD_RELOC_NIOS2_R2_L5I4X1
6496 ENUMX
6497   BFD_RELOC_NIOS2_R2_T1X1I6
6498 ENUMX
6499   BFD_RELOC_NIOS2_R2_T1X1I6_2
6500 ENUMDOC
6501   Relocations used by the Altera Nios II core.
6502
6503 ENUM
6504   BFD_RELOC_PRU_U16
6505 ENUMDOC
6506   PRU LDI 16-bit unsigned data-memory relocation.
6507 ENUM
6508   BFD_RELOC_PRU_U16_PMEMIMM
6509 ENUMDOC
6510   PRU LDI 16-bit unsigned instruction-memory relocation.
6511 ENUM
6512   BFD_RELOC_PRU_LDI32
6513 ENUMDOC
6514   PRU relocation for two consecutive LDI load instructions that load a
6515   32 bit value into a register. If the higher bits are all zero, then
6516   the second instruction may be relaxed.
6517 ENUM
6518   BFD_RELOC_PRU_S10_PCREL
6519 ENUMDOC
6520   PRU QBBx 10-bit signed PC-relative relocation.
6521 ENUM
6522   BFD_RELOC_PRU_U8_PCREL
6523 ENUMDOC
6524   PRU 8-bit unsigned relocation used for the LOOP instruction.
6525 ENUM
6526   BFD_RELOC_PRU_32_PMEM
6527 ENUMX
6528   BFD_RELOC_PRU_16_PMEM
6529 ENUMDOC
6530   PRU Program Memory relocations.  Used to convert from byte addressing to
6531   32-bit word addressing.
6532 ENUM
6533   BFD_RELOC_PRU_GNU_DIFF8
6534 ENUMX
6535   BFD_RELOC_PRU_GNU_DIFF16
6536 ENUMX
6537   BFD_RELOC_PRU_GNU_DIFF32
6538 ENUMX
6539   BFD_RELOC_PRU_GNU_DIFF16_PMEM
6540 ENUMX
6541   BFD_RELOC_PRU_GNU_DIFF32_PMEM
6542 ENUMDOC
6543   PRU relocations to mark the difference of two local symbols.
6544   These are only needed to support linker relaxation and can be ignored
6545   when not relaxing.  The field is set to the value of the difference
6546   assuming no relaxation.  The relocation encodes the position of the
6547   second symbol so the linker can determine whether to adjust the field
6548   value. The PMEM variants encode the word difference, instead of byte
6549   difference between symbols.
6550
6551 ENUM
6552   BFD_RELOC_IQ2000_OFFSET_16
6553 ENUMX
6554   BFD_RELOC_IQ2000_OFFSET_21
6555 ENUMX
6556   BFD_RELOC_IQ2000_UHI16
6557 ENUMDOC
6558   IQ2000 Relocations.
6559
6560 ENUM
6561   BFD_RELOC_XTENSA_RTLD
6562 ENUMDOC
6563   Special Xtensa relocation used only by PLT entries in ELF shared
6564   objects to indicate that the runtime linker should set the value
6565   to one of its own internal functions or data structures.
6566 ENUM
6567   BFD_RELOC_XTENSA_GLOB_DAT
6568 ENUMX
6569   BFD_RELOC_XTENSA_JMP_SLOT
6570 ENUMX
6571   BFD_RELOC_XTENSA_RELATIVE
6572 ENUMDOC
6573   Xtensa relocations for ELF shared objects.
6574 ENUM
6575   BFD_RELOC_XTENSA_PLT
6576 ENUMDOC
6577   Xtensa relocation used in ELF object files for symbols that may require
6578   PLT entries.  Otherwise, this is just a generic 32-bit relocation.
6579 ENUM
6580   BFD_RELOC_XTENSA_DIFF8
6581 ENUMX
6582   BFD_RELOC_XTENSA_DIFF16
6583 ENUMX
6584   BFD_RELOC_XTENSA_DIFF32
6585 ENUMDOC
6586   Xtensa relocations for backward compatibility.  These have been replaced
6587   by BFD_RELOC_XTENSA_PDIFF and BFD_RELOC_XTENSA_NDIFF.
6588   Xtensa relocations to mark the difference of two local symbols.
6589   These are only needed to support linker relaxation and can be ignored
6590   when not relaxing.  The field is set to the value of the difference
6591   assuming no relaxation.  The relocation encodes the position of the
6592   first symbol so the linker can determine whether to adjust the field
6593   value.
6594 ENUM
6595   BFD_RELOC_XTENSA_SLOT0_OP
6596 ENUMX
6597   BFD_RELOC_XTENSA_SLOT1_OP
6598 ENUMX
6599   BFD_RELOC_XTENSA_SLOT2_OP
6600 ENUMX
6601   BFD_RELOC_XTENSA_SLOT3_OP
6602 ENUMX
6603   BFD_RELOC_XTENSA_SLOT4_OP
6604 ENUMX
6605   BFD_RELOC_XTENSA_SLOT5_OP
6606 ENUMX
6607   BFD_RELOC_XTENSA_SLOT6_OP
6608 ENUMX
6609   BFD_RELOC_XTENSA_SLOT7_OP
6610 ENUMX
6611   BFD_RELOC_XTENSA_SLOT8_OP
6612 ENUMX
6613   BFD_RELOC_XTENSA_SLOT9_OP
6614 ENUMX
6615   BFD_RELOC_XTENSA_SLOT10_OP
6616 ENUMX
6617   BFD_RELOC_XTENSA_SLOT11_OP
6618 ENUMX
6619   BFD_RELOC_XTENSA_SLOT12_OP
6620 ENUMX
6621   BFD_RELOC_XTENSA_SLOT13_OP
6622 ENUMX
6623   BFD_RELOC_XTENSA_SLOT14_OP
6624 ENUMDOC
6625   Generic Xtensa relocations for instruction operands.  Only the slot
6626   number is encoded in the relocation.  The relocation applies to the
6627   last PC-relative immediate operand, or if there are no PC-relative
6628   immediates, to the last immediate operand.
6629 ENUM
6630   BFD_RELOC_XTENSA_SLOT0_ALT
6631 ENUMX
6632   BFD_RELOC_XTENSA_SLOT1_ALT
6633 ENUMX
6634   BFD_RELOC_XTENSA_SLOT2_ALT
6635 ENUMX
6636   BFD_RELOC_XTENSA_SLOT3_ALT
6637 ENUMX
6638   BFD_RELOC_XTENSA_SLOT4_ALT
6639 ENUMX
6640   BFD_RELOC_XTENSA_SLOT5_ALT
6641 ENUMX
6642   BFD_RELOC_XTENSA_SLOT6_ALT
6643 ENUMX
6644   BFD_RELOC_XTENSA_SLOT7_ALT
6645 ENUMX
6646   BFD_RELOC_XTENSA_SLOT8_ALT
6647 ENUMX
6648   BFD_RELOC_XTENSA_SLOT9_ALT
6649 ENUMX
6650   BFD_RELOC_XTENSA_SLOT10_ALT
6651 ENUMX
6652   BFD_RELOC_XTENSA_SLOT11_ALT
6653 ENUMX
6654   BFD_RELOC_XTENSA_SLOT12_ALT
6655 ENUMX
6656   BFD_RELOC_XTENSA_SLOT13_ALT
6657 ENUMX
6658   BFD_RELOC_XTENSA_SLOT14_ALT
6659 ENUMDOC
6660   Alternate Xtensa relocations.  Only the slot is encoded in the
6661   relocation.  The meaning of these relocations is opcode-specific.
6662 ENUM
6663   BFD_RELOC_XTENSA_OP0
6664 ENUMX
6665   BFD_RELOC_XTENSA_OP1
6666 ENUMX
6667   BFD_RELOC_XTENSA_OP2
6668 ENUMDOC
6669   Xtensa relocations for backward compatibility.  These have all been
6670   replaced by BFD_RELOC_XTENSA_SLOT0_OP.
6671 ENUM
6672   BFD_RELOC_XTENSA_ASM_EXPAND
6673 ENUMDOC
6674   Xtensa relocation to mark that the assembler expanded the
6675   instructions from an original target.  The expansion size is
6676   encoded in the reloc size.
6677 ENUM
6678   BFD_RELOC_XTENSA_ASM_SIMPLIFY
6679 ENUMDOC
6680   Xtensa relocation to mark that the linker should simplify
6681   assembler-expanded instructions.  This is commonly used
6682   internally by the linker after analysis of a
6683   BFD_RELOC_XTENSA_ASM_EXPAND.
6684 ENUM
6685   BFD_RELOC_XTENSA_TLSDESC_FN
6686 ENUMX
6687   BFD_RELOC_XTENSA_TLSDESC_ARG
6688 ENUMX
6689   BFD_RELOC_XTENSA_TLS_DTPOFF
6690 ENUMX
6691   BFD_RELOC_XTENSA_TLS_TPOFF
6692 ENUMX
6693   BFD_RELOC_XTENSA_TLS_FUNC
6694 ENUMX
6695   BFD_RELOC_XTENSA_TLS_ARG
6696 ENUMX
6697   BFD_RELOC_XTENSA_TLS_CALL
6698 ENUMDOC
6699   Xtensa TLS relocations.
6700 ENUM
6701   BFD_RELOC_XTENSA_PDIFF8
6702 ENUMX
6703   BFD_RELOC_XTENSA_PDIFF16
6704 ENUMX
6705   BFD_RELOC_XTENSA_PDIFF32
6706 ENUMX
6707   BFD_RELOC_XTENSA_NDIFF8
6708 ENUMX
6709   BFD_RELOC_XTENSA_NDIFF16
6710 ENUMX
6711   BFD_RELOC_XTENSA_NDIFF32
6712 ENUMDOC
6713   Xtensa relocations to mark the difference of two local symbols.
6714   These are only needed to support linker relaxation and can be ignored
6715   when not relaxing.  The field is set to the value of the difference
6716   assuming no relaxation.  The relocation encodes the position of the
6717   subtracted symbol so the linker can determine whether to adjust the field
6718   value.  PDIFF relocations are used for positive differences, NDIFF
6719   relocations are used for negative differences.  The difference value
6720   is treated as unsigned with these relocation types, giving full
6721   8/16 value ranges.
6722
6723 ENUM
6724   BFD_RELOC_Z80_DISP8
6725 ENUMDOC
6726   8 bit signed offset in (ix+d) or (iy+d).
6727 ENUM
6728   BFD_RELOC_Z80_BYTE0
6729 ENUMDOC
6730   First 8 bits of multibyte (32, 24 or 16 bit) value.
6731 ENUM
6732   BFD_RELOC_Z80_BYTE1
6733 ENUMDOC
6734   Second 8 bits of multibyte (32, 24 or 16 bit) value.
6735 ENUM
6736   BFD_RELOC_Z80_BYTE2
6737 ENUMDOC
6738   Third 8 bits of multibyte (32 or 24 bit) value.
6739 ENUM
6740   BFD_RELOC_Z80_BYTE3
6741 ENUMDOC
6742   Fourth 8 bits of multibyte (32 bit) value.
6743 ENUM
6744   BFD_RELOC_Z80_WORD0
6745 ENUMDOC
6746   Lowest 16 bits of multibyte (32 or 24 bit) value.
6747 ENUM
6748   BFD_RELOC_Z80_WORD1
6749 ENUMDOC
6750   Highest 16 bits of multibyte (32 or 24 bit) value.
6751 ENUM
6752   BFD_RELOC_Z80_16_BE
6753 ENUMDOC
6754   Like BFD_RELOC_16 but big-endian.
6755
6756 ENUM
6757   BFD_RELOC_Z8K_DISP7
6758 ENUMDOC
6759   DJNZ offset.
6760 ENUM
6761   BFD_RELOC_Z8K_CALLR
6762 ENUMDOC
6763   CALR offset.
6764 ENUM
6765   BFD_RELOC_Z8K_IMM4L
6766 ENUMDOC
6767   4 bit value.
6768
6769 ENUM
6770    BFD_RELOC_LM32_CALL
6771 ENUMX
6772    BFD_RELOC_LM32_BRANCH
6773 ENUMX
6774    BFD_RELOC_LM32_16_GOT
6775 ENUMX
6776    BFD_RELOC_LM32_GOTOFF_HI16
6777 ENUMX
6778    BFD_RELOC_LM32_GOTOFF_LO16
6779 ENUMX
6780    BFD_RELOC_LM32_COPY
6781 ENUMX
6782    BFD_RELOC_LM32_GLOB_DAT
6783 ENUMX
6784    BFD_RELOC_LM32_JMP_SLOT
6785 ENUMX
6786    BFD_RELOC_LM32_RELATIVE
6787 ENUMDOC
6788  Lattice Mico32 relocations.
6789
6790 ENUM
6791   BFD_RELOC_MACH_O_SECTDIFF
6792 ENUMDOC
6793   Difference between two section addreses.  Must be followed by a
6794   BFD_RELOC_MACH_O_PAIR.
6795 ENUM
6796   BFD_RELOC_MACH_O_LOCAL_SECTDIFF
6797 ENUMDOC
6798   Like BFD_RELOC_MACH_O_SECTDIFF but with a local symbol.
6799 ENUM
6800   BFD_RELOC_MACH_O_PAIR
6801 ENUMDOC
6802   Pair of relocation.  Contains the first symbol.
6803 ENUM
6804   BFD_RELOC_MACH_O_SUBTRACTOR32
6805 ENUMDOC
6806   Symbol will be substracted.  Must be followed by a BFD_RELOC_32.
6807 ENUM
6808   BFD_RELOC_MACH_O_SUBTRACTOR64
6809 ENUMDOC
6810   Symbol will be substracted.  Must be followed by a BFD_RELOC_64.
6811
6812 ENUM
6813   BFD_RELOC_MACH_O_X86_64_BRANCH32
6814 ENUMX
6815   BFD_RELOC_MACH_O_X86_64_BRANCH8
6816 ENUMDOC
6817   PCREL relocations.  They are marked as branch to create PLT entry if
6818   required.
6819 ENUM
6820   BFD_RELOC_MACH_O_X86_64_GOT
6821 ENUMDOC
6822   Used when referencing a GOT entry.
6823 ENUM
6824   BFD_RELOC_MACH_O_X86_64_GOT_LOAD
6825 ENUMDOC
6826   Used when loading a GOT entry with movq.  It is specially marked so that
6827   the linker could optimize the movq to a leaq if possible.
6828 ENUM
6829   BFD_RELOC_MACH_O_X86_64_PCREL32_1
6830 ENUMDOC
6831   Same as BFD_RELOC_32_PCREL but with an implicit -1 addend.
6832 ENUM
6833   BFD_RELOC_MACH_O_X86_64_PCREL32_2
6834 ENUMDOC
6835   Same as BFD_RELOC_32_PCREL but with an implicit -2 addend.
6836 ENUM
6837   BFD_RELOC_MACH_O_X86_64_PCREL32_4
6838 ENUMDOC
6839   Same as BFD_RELOC_32_PCREL but with an implicit -4 addend.
6840 ENUM
6841   BFD_RELOC_MACH_O_X86_64_TLV
6842 ENUMDOC
6843   Used when referencing a TLV entry.
6844
6845
6846 ENUM
6847   BFD_RELOC_MACH_O_ARM64_ADDEND
6848 ENUMDOC
6849   Addend for PAGE or PAGEOFF.
6850 ENUM
6851   BFD_RELOC_MACH_O_ARM64_GOT_LOAD_PAGE21
6852 ENUMDOC
6853   Relative offset to page of GOT slot.
6854 ENUM
6855   BFD_RELOC_MACH_O_ARM64_GOT_LOAD_PAGEOFF12
6856 ENUMDOC
6857   Relative offset within page of GOT slot.
6858 ENUM
6859   BFD_RELOC_MACH_O_ARM64_POINTER_TO_GOT
6860 ENUMDOC
6861   Address of a GOT entry.
6862
6863 ENUM
6864   BFD_RELOC_MICROBLAZE_32_LO
6865 ENUMDOC
6866   This is a 32 bit reloc for the microblaze that stores the
6867   low 16 bits of a value
6868 ENUM
6869   BFD_RELOC_MICROBLAZE_32_LO_PCREL
6870 ENUMDOC
6871   This is a 32 bit pc-relative reloc for the microblaze that
6872   stores the low 16 bits of a value
6873 ENUM
6874   BFD_RELOC_MICROBLAZE_32_ROSDA
6875 ENUMDOC
6876   This is a 32 bit reloc for the microblaze that stores a
6877   value relative to the read-only small data area anchor
6878 ENUM
6879   BFD_RELOC_MICROBLAZE_32_RWSDA
6880 ENUMDOC
6881   This is a 32 bit reloc for the microblaze that stores a
6882   value relative to the read-write small data area anchor
6883 ENUM
6884   BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM
6885 ENUMDOC
6886   This is a 32 bit reloc for the microblaze to handle
6887   expressions of the form "Symbol Op Symbol"
6888 ENUM
6889   BFD_RELOC_MICROBLAZE_64_NONE
6890 ENUMDOC
6891   This is a 64 bit reloc that stores the 32 bit pc relative
6892   value in two words (with an imm instruction).  No relocation is
6893   done here - only used for relaxing
6894 ENUM
6895   BFD_RELOC_MICROBLAZE_64_GOTPC
6896 ENUMDOC
6897   This is a 64 bit reloc that stores the 32 bit pc relative
6898   value in two words (with an imm instruction).  The relocation is
6899   PC-relative GOT offset
6900 ENUM
6901   BFD_RELOC_MICROBLAZE_64_GOT
6902 ENUMDOC
6903   This is a 64 bit reloc that stores the 32 bit pc relative
6904   value in two words (with an imm instruction).  The relocation is
6905   GOT offset
6906 ENUM
6907   BFD_RELOC_MICROBLAZE_64_PLT
6908 ENUMDOC
6909   This is a 64 bit reloc that stores the 32 bit pc relative
6910   value in two words (with an imm instruction).  The relocation is
6911   PC-relative offset into PLT
6912 ENUM
6913   BFD_RELOC_MICROBLAZE_64_GOTOFF
6914 ENUMDOC
6915   This is a 64 bit reloc that stores the 32 bit GOT relative
6916   value in two words (with an imm instruction).  The relocation is
6917   relative offset from _GLOBAL_OFFSET_TABLE_
6918 ENUM
6919   BFD_RELOC_MICROBLAZE_32_GOTOFF
6920 ENUMDOC
6921   This is a 32 bit reloc that stores the 32 bit GOT relative
6922   value in a word.  The relocation is relative offset from
6923   _GLOBAL_OFFSET_TABLE_
6924 ENUM
6925   BFD_RELOC_MICROBLAZE_COPY
6926 ENUMDOC
6927   This is used to tell the dynamic linker to copy the value out of
6928   the dynamic object into the runtime process image.
6929 ENUM
6930   BFD_RELOC_MICROBLAZE_64_TLS
6931 ENUMDOC
6932   Unused Reloc
6933 ENUM
6934   BFD_RELOC_MICROBLAZE_64_TLSGD
6935 ENUMDOC
6936   This is a 64 bit reloc that stores the 32 bit GOT relative value
6937   of the GOT TLS GD info entry in two words (with an imm instruction). The
6938   relocation is GOT offset.
6939 ENUM
6940   BFD_RELOC_MICROBLAZE_64_TLSLD
6941 ENUMDOC
6942   This is a 64 bit reloc that stores the 32 bit GOT relative value
6943   of the GOT TLS LD info entry in two words (with an imm instruction). The
6944   relocation is GOT offset.
6945 ENUM
6946   BFD_RELOC_MICROBLAZE_32_TLSDTPMOD
6947 ENUMDOC
6948   This is a 32 bit reloc that stores the Module ID to GOT(n).
6949 ENUM
6950   BFD_RELOC_MICROBLAZE_32_TLSDTPREL
6951 ENUMDOC
6952   This is a 32 bit reloc that stores TLS offset to GOT(n+1).
6953 ENUM
6954   BFD_RELOC_MICROBLAZE_64_TLSDTPREL
6955 ENUMDOC
6956   This is a 32 bit reloc for storing TLS offset to two words (uses imm
6957   instruction)
6958 ENUM
6959   BFD_RELOC_MICROBLAZE_64_TLSGOTTPREL
6960 ENUMDOC
6961   This is a 64 bit reloc that stores 32-bit thread pointer relative offset
6962   to two words (uses imm instruction).
6963 ENUM
6964   BFD_RELOC_MICROBLAZE_64_TLSTPREL
6965 ENUMDOC
6966   This is a 64 bit reloc that stores 32-bit thread pointer relative offset
6967   to two words (uses imm instruction).
6968 ENUM
6969   BFD_RELOC_MICROBLAZE_64_TEXTPCREL
6970 ENUMDOC
6971   This is a 64 bit reloc that stores the 32 bit pc relative
6972   value in two words (with an imm instruction).  The relocation is
6973   PC-relative offset from start of TEXT.
6974 ENUM
6975   BFD_RELOC_MICROBLAZE_64_TEXTREL
6976 ENUMDOC
6977   This is a 64 bit reloc that stores the 32 bit offset
6978   value in two words (with an imm instruction).  The relocation is
6979   relative offset from start of TEXT.
6980
6981 ENUM
6982   BFD_RELOC_AARCH64_RELOC_START
6983 ENUMDOC
6984   AArch64 pseudo relocation code to mark the start of the AArch64
6985   relocation enumerators.  N.B. the order of the enumerators is
6986   important as several tables in the AArch64 bfd backend are indexed
6987   by these enumerators; make sure they are all synced.
6988 ENUM
6989   BFD_RELOC_AARCH64_NULL
6990 ENUMDOC
6991   Deprecated AArch64 null relocation code.
6992 ENUM
6993   BFD_RELOC_AARCH64_NONE
6994 ENUMDOC
6995   AArch64 null relocation code.
6996 ENUM
6997   BFD_RELOC_AARCH64_64
6998 ENUMX
6999   BFD_RELOC_AARCH64_32
7000 ENUMX
7001   BFD_RELOC_AARCH64_16
7002 ENUMDOC
7003   Basic absolute relocations of N bits.  These are equivalent to
7004 BFD_RELOC_N and they were added to assist the indexing of the howto
7005 table.
7006 ENUM
7007   BFD_RELOC_AARCH64_64_PCREL
7008 ENUMX
7009   BFD_RELOC_AARCH64_32_PCREL
7010 ENUMX
7011   BFD_RELOC_AARCH64_16_PCREL
7012 ENUMDOC
7013   PC-relative relocations.  These are equivalent to BFD_RELOC_N_PCREL
7014 and they were added to assist the indexing of the howto table.
7015 ENUM
7016   BFD_RELOC_AARCH64_MOVW_G0
7017 ENUMDOC
7018   AArch64 MOV[NZK] instruction with most significant bits 0 to 15
7019   of an unsigned address/value.
7020 ENUM
7021   BFD_RELOC_AARCH64_MOVW_G0_NC
7022 ENUMDOC
7023   AArch64 MOV[NZK] instruction with less significant bits 0 to 15 of
7024   an address/value.  No overflow checking.
7025 ENUM
7026   BFD_RELOC_AARCH64_MOVW_G1
7027 ENUMDOC
7028   AArch64 MOV[NZK] instruction with most significant bits 16 to 31
7029   of an unsigned address/value.
7030 ENUM
7031   BFD_RELOC_AARCH64_MOVW_G1_NC
7032 ENUMDOC
7033   AArch64 MOV[NZK] instruction with less significant bits 16 to 31
7034   of an address/value.  No overflow checking.
7035 ENUM
7036   BFD_RELOC_AARCH64_MOVW_G2
7037 ENUMDOC
7038   AArch64 MOV[NZK] instruction with most significant bits 32 to 47
7039   of an unsigned address/value.
7040 ENUM
7041   BFD_RELOC_AARCH64_MOVW_G2_NC
7042 ENUMDOC
7043   AArch64 MOV[NZK] instruction with less significant bits 32 to 47
7044   of an address/value.  No overflow checking.
7045 ENUM
7046   BFD_RELOC_AARCH64_MOVW_G3
7047 ENUMDOC
7048   AArch64 MOV[NZK] instruction with most signficant bits 48 to 64
7049   of a signed or unsigned address/value.
7050 ENUM
7051   BFD_RELOC_AARCH64_MOVW_G0_S
7052 ENUMDOC
7053   AArch64 MOV[NZ] instruction with most significant bits 0 to 15
7054   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
7055   value's sign.
7056 ENUM
7057   BFD_RELOC_AARCH64_MOVW_G1_S
7058 ENUMDOC
7059   AArch64 MOV[NZ] instruction with most significant bits 16 to 31
7060   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
7061   value's sign.
7062 ENUM
7063   BFD_RELOC_AARCH64_MOVW_G2_S
7064 ENUMDOC
7065   AArch64 MOV[NZ] instruction with most significant bits 32 to 47
7066   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
7067   value's sign.
7068 ENUM
7069   BFD_RELOC_AARCH64_MOVW_PREL_G0
7070 ENUMDOC
7071   AArch64 MOV[NZ] instruction with most significant bits 0 to 15
7072   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
7073   value's sign.
7074 ENUM
7075   BFD_RELOC_AARCH64_MOVW_PREL_G0_NC
7076 ENUMDOC
7077   AArch64 MOV[NZ] instruction with most significant bits 0 to 15
7078   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
7079   value's sign.
7080 ENUM
7081   BFD_RELOC_AARCH64_MOVW_PREL_G1
7082 ENUMDOC
7083   AArch64 MOVK instruction with most significant bits 16 to 31
7084   of a signed value.
7085 ENUM
7086   BFD_RELOC_AARCH64_MOVW_PREL_G1_NC
7087 ENUMDOC
7088   AArch64 MOVK instruction with most significant bits 16 to 31
7089   of a signed value.
7090 ENUM
7091   BFD_RELOC_AARCH64_MOVW_PREL_G2
7092 ENUMDOC
7093   AArch64 MOVK instruction with most significant bits 32 to 47
7094   of a signed value.
7095 ENUM
7096   BFD_RELOC_AARCH64_MOVW_PREL_G2_NC
7097 ENUMDOC
7098   AArch64 MOVK instruction with most significant bits 32 to 47
7099   of a signed value.
7100 ENUM
7101   BFD_RELOC_AARCH64_MOVW_PREL_G3
7102 ENUMDOC
7103   AArch64 MOVK instruction with most significant bits 47 to 63
7104   of a signed value.
7105 ENUM
7106   BFD_RELOC_AARCH64_LD_LO19_PCREL
7107 ENUMDOC
7108   AArch64 Load Literal instruction, holding a 19 bit pc-relative word
7109   offset.  The lowest two bits must be zero and are not stored in the
7110   instruction, giving a 21 bit signed byte offset.
7111 ENUM
7112   BFD_RELOC_AARCH64_ADR_LO21_PCREL
7113 ENUMDOC
7114   AArch64 ADR instruction, holding a simple 21 bit pc-relative byte offset.
7115 ENUM
7116   BFD_RELOC_AARCH64_ADR_HI21_PCREL
7117 ENUMDOC
7118   AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page
7119   offset, giving a 4KB aligned page base address.
7120 ENUM
7121   BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL
7122 ENUMDOC
7123   AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page
7124   offset, giving a 4KB aligned page base address, but with no overflow
7125   checking.
7126 ENUM
7127   BFD_RELOC_AARCH64_ADD_LO12
7128 ENUMDOC
7129   AArch64 ADD immediate instruction, holding bits 0 to 11 of the address.
7130   Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
7131 ENUM
7132   BFD_RELOC_AARCH64_LDST8_LO12
7133 ENUMDOC
7134   AArch64 8-bit load/store instruction, holding bits 0 to 11 of the
7135   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
7136 ENUM
7137   BFD_RELOC_AARCH64_TSTBR14
7138 ENUMDOC
7139   AArch64 14 bit pc-relative test bit and branch.
7140   The lowest two bits must be zero and are not stored in the instruction,
7141   giving a 16 bit signed byte offset.
7142 ENUM
7143   BFD_RELOC_AARCH64_BRANCH19
7144 ENUMDOC
7145   AArch64 19 bit pc-relative conditional branch and compare & branch.
7146   The lowest two bits must be zero and are not stored in the instruction,
7147   giving a 21 bit signed byte offset.
7148 ENUM
7149   BFD_RELOC_AARCH64_JUMP26
7150 ENUMDOC
7151   AArch64 26 bit pc-relative unconditional branch.
7152   The lowest two bits must be zero and are not stored in the instruction,
7153   giving a 28 bit signed byte offset.
7154 ENUM
7155   BFD_RELOC_AARCH64_CALL26
7156 ENUMDOC
7157   AArch64 26 bit pc-relative unconditional branch and link.
7158   The lowest two bits must be zero and are not stored in the instruction,
7159   giving a 28 bit signed byte offset.
7160 ENUM
7161   BFD_RELOC_AARCH64_LDST16_LO12
7162 ENUMDOC
7163   AArch64 16-bit load/store instruction, holding bits 0 to 11 of the
7164   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
7165 ENUM
7166   BFD_RELOC_AARCH64_LDST32_LO12
7167 ENUMDOC
7168   AArch64 32-bit load/store instruction, holding bits 0 to 11 of the
7169   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
7170 ENUM
7171   BFD_RELOC_AARCH64_LDST64_LO12
7172 ENUMDOC
7173   AArch64 64-bit load/store instruction, holding bits 0 to 11 of the
7174   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
7175 ENUM
7176   BFD_RELOC_AARCH64_LDST128_LO12
7177 ENUMDOC
7178   AArch64 128-bit load/store instruction, holding bits 0 to 11 of the
7179   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
7180 ENUM
7181   BFD_RELOC_AARCH64_GOT_LD_PREL19
7182 ENUMDOC
7183   AArch64 Load Literal instruction, holding a 19 bit PC relative word
7184   offset of the global offset table entry for a symbol.  The lowest two
7185   bits must be zero and are not stored in the instruction, giving a 21
7186   bit signed byte offset.  This relocation type requires signed overflow
7187   checking.
7188 ENUM
7189   BFD_RELOC_AARCH64_ADR_GOT_PAGE
7190 ENUMDOC
7191   Get to the page base of the global offset table entry for a symbol as
7192   part of an ADRP instruction using a 21 bit PC relative value.Used in
7193   conjunction with BFD_RELOC_AARCH64_LD64_GOT_LO12_NC.
7194 ENUM
7195   BFD_RELOC_AARCH64_LD64_GOT_LO12_NC
7196 ENUMDOC
7197   Unsigned 12 bit byte offset for 64 bit load/store from the page of
7198   the GOT entry for this symbol.  Used in conjunction with
7199   BFD_RELOC_AARCH64_ADR_GOT_PAGE.  Valid in LP64 ABI only.
7200 ENUM
7201   BFD_RELOC_AARCH64_LD32_GOT_LO12_NC
7202 ENUMDOC
7203   Unsigned 12 bit byte offset for 32 bit load/store from the page of
7204   the GOT entry for this symbol.  Used in conjunction with
7205   BFD_RELOC_AARCH64_ADR_GOT_PAGE.  Valid in ILP32 ABI only.
7206  ENUM
7207   BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC
7208 ENUMDOC
7209   Unsigned 16 bit byte offset for 64 bit load/store from the GOT entry
7210   for this symbol.  Valid in LP64 ABI only.
7211 ENUM
7212   BFD_RELOC_AARCH64_MOVW_GOTOFF_G1
7213 ENUMDOC
7214   Unsigned 16 bit byte higher offset for 64 bit load/store from the GOT entry
7215   for this symbol.  Valid in LP64 ABI only.
7216 ENUM
7217   BFD_RELOC_AARCH64_LD64_GOTOFF_LO15
7218 ENUMDOC
7219   Unsigned 15 bit byte offset for 64 bit load/store from the page of
7220   the GOT entry for this symbol.  Valid in LP64 ABI only.
7221 ENUM
7222   BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14
7223 ENUMDOC
7224   Scaled 14 bit byte offset to the page base of the global offset table.
7225 ENUM
7226   BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15
7227 ENUMDOC
7228   Scaled 15 bit byte offset to the page base of the global offset table.
7229 ENUM
7230   BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21
7231 ENUMDOC
7232   Get to the page base of the global offset table entry for a symbols
7233   tls_index structure as part of an adrp instruction using a 21 bit PC
7234   relative value.  Used in conjunction with
7235   BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC.
7236 ENUM
7237   BFD_RELOC_AARCH64_TLSGD_ADR_PREL21
7238 ENUMDOC
7239   AArch64 TLS General Dynamic
7240 ENUM
7241   BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC
7242 ENUMDOC
7243   Unsigned 12 bit byte offset to global offset table entry for a symbols
7244   tls_index structure.  Used in conjunction with
7245   BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21.
7246 ENUM
7247   BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC
7248 ENUMDOC
7249   AArch64 TLS General Dynamic relocation.
7250 ENUM
7251   BFD_RELOC_AARCH64_TLSGD_MOVW_G1
7252 ENUMDOC
7253   AArch64 TLS General Dynamic relocation.
7254 ENUM
7255   BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21
7256 ENUMDOC
7257   AArch64 TLS INITIAL EXEC relocation.
7258 ENUM
7259   BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC
7260 ENUMDOC
7261   AArch64 TLS INITIAL EXEC relocation.
7262 ENUM
7263   BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC
7264 ENUMDOC
7265   AArch64 TLS INITIAL EXEC relocation.
7266 ENUM
7267   BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19
7268 ENUMDOC
7269   AArch64 TLS INITIAL EXEC relocation.
7270 ENUM
7271   BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC
7272 ENUMDOC
7273   AArch64 TLS INITIAL EXEC relocation.
7274 ENUM
7275   BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1
7276 ENUMDOC
7277   AArch64 TLS INITIAL EXEC relocation.
7278 ENUM
7279   BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_HI12
7280 ENUMDOC
7281   bit[23:12] of byte offset to module TLS base address.
7282 ENUM
7283   BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12
7284 ENUMDOC
7285   Unsigned 12 bit byte offset to module TLS base address.
7286 ENUM
7287   BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12_NC
7288 ENUMDOC
7289   No overflow check version of BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12.
7290 ENUM
7291   BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC
7292 ENUMDOC
7293   Unsigned 12 bit byte offset to global offset table entry for a symbols
7294   tls_index structure.  Used in conjunction with
7295   BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21.
7296 ENUM
7297   BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21
7298 ENUMDOC
7299   GOT entry page address for AArch64 TLS Local Dynamic, used with ADRP
7300   instruction.
7301 ENUM
7302   BFD_RELOC_AARCH64_TLSLD_ADR_PREL21
7303 ENUMDOC
7304   GOT entry address for AArch64 TLS Local Dynamic, used with ADR instruction.
7305 ENUM
7306   BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12
7307 ENUMDOC
7308   bit[11:1] of byte offset to module TLS base address, encoded in ldst
7309   instructions.
7310 ENUM
7311   BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC
7312 ENUMDOC
7313   Similar as BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12, but no overflow check.
7314 ENUM
7315   BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12
7316 ENUMDOC
7317   bit[11:2] of byte offset to module TLS base address, encoded in ldst
7318   instructions.
7319 ENUM
7320   BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC
7321 ENUMDOC
7322   Similar as BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12, but no overflow check.
7323 ENUM
7324   BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12
7325 ENUMDOC
7326   bit[11:3] of byte offset to module TLS base address, encoded in ldst
7327   instructions.
7328 ENUM
7329   BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC
7330 ENUMDOC
7331   Similar as BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12, but no overflow check.
7332 ENUM
7333   BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12
7334 ENUMDOC
7335   bit[11:0] of byte offset to module TLS base address, encoded in ldst
7336   instructions.
7337 ENUM
7338   BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC
7339 ENUMDOC
7340   Similar as BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12, but no overflow check.
7341 ENUM
7342   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0
7343 ENUMDOC
7344   bit[15:0] of byte offset to module TLS base address.
7345 ENUM
7346   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0_NC
7347 ENUMDOC
7348   No overflow check version of BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0
7349 ENUM
7350   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1
7351 ENUMDOC
7352   bit[31:16] of byte offset to module TLS base address.
7353 ENUM
7354   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1_NC
7355 ENUMDOC
7356   No overflow check version of BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1
7357 ENUM
7358   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G2
7359 ENUMDOC
7360   bit[47:32] of byte offset to module TLS base address.
7361 ENUM
7362   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2
7363 ENUMDOC
7364   AArch64 TLS LOCAL EXEC relocation.
7365 ENUM
7366   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1
7367 ENUMDOC
7368   AArch64 TLS LOCAL EXEC relocation.
7369 ENUM
7370   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC
7371 ENUMDOC
7372   AArch64 TLS LOCAL EXEC relocation.
7373 ENUM
7374   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0
7375 ENUMDOC
7376   AArch64 TLS LOCAL EXEC relocation.
7377 ENUM
7378   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC
7379 ENUMDOC
7380   AArch64 TLS LOCAL EXEC relocation.
7381 ENUM
7382   BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12
7383 ENUMDOC
7384   AArch64 TLS LOCAL EXEC relocation.
7385 ENUM
7386   BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12
7387 ENUMDOC
7388   AArch64 TLS LOCAL EXEC relocation.
7389 ENUM
7390   BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC
7391 ENUMDOC
7392   AArch64 TLS LOCAL EXEC relocation.
7393 ENUM
7394   BFD_RELOC_AARCH64_TLSLE_LDST16_TPREL_LO12
7395 ENUMDOC
7396   bit[11:1] of byte offset to module TLS base address, encoded in ldst
7397   instructions.
7398 ENUM
7399   BFD_RELOC_AARCH64_TLSLE_LDST16_TPREL_LO12_NC
7400 ENUMDOC
7401   Similar as BFD_RELOC_AARCH64_TLSLE_LDST16_TPREL_LO12, but no overflow check.
7402 ENUM
7403   BFD_RELOC_AARCH64_TLSLE_LDST32_TPREL_LO12
7404 ENUMDOC
7405   bit[11:2] of byte offset to module TLS base address, encoded in ldst
7406   instructions.
7407 ENUM
7408   BFD_RELOC_AARCH64_TLSLE_LDST32_TPREL_LO12_NC
7409 ENUMDOC
7410   Similar as BFD_RELOC_AARCH64_TLSLE_LDST32_TPREL_LO12, but no overflow check.
7411 ENUM
7412   BFD_RELOC_AARCH64_TLSLE_LDST64_TPREL_LO12
7413 ENUMDOC
7414   bit[11:3] of byte offset to module TLS base address, encoded in ldst
7415   instructions.
7416 ENUM
7417   BFD_RELOC_AARCH64_TLSLE_LDST64_TPREL_LO12_NC
7418 ENUMDOC
7419   Similar as BFD_RELOC_AARCH64_TLSLE_LDST64_TPREL_LO12, but no overflow check.
7420 ENUM
7421   BFD_RELOC_AARCH64_TLSLE_LDST8_TPREL_LO12
7422 ENUMDOC
7423   bit[11:0] of byte offset to module TLS base address, encoded in ldst
7424   instructions.
7425 ENUM
7426   BFD_RELOC_AARCH64_TLSLE_LDST8_TPREL_LO12_NC
7427 ENUMDOC
7428   Similar as BFD_RELOC_AARCH64_TLSLE_LDST8_TPREL_LO12, but no overflow check.
7429 ENUM
7430   BFD_RELOC_AARCH64_TLSDESC_LD_PREL19
7431 ENUMDOC
7432   AArch64 TLS DESC relocation.
7433 ENUM
7434   BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21
7435 ENUMDOC
7436   AArch64 TLS DESC relocation.
7437 ENUM
7438   BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21
7439 ENUMDOC
7440   AArch64 TLS DESC relocation.
7441 ENUM
7442   BFD_RELOC_AARCH64_TLSDESC_LD64_LO12
7443 ENUMDOC
7444   AArch64 TLS DESC relocation.
7445 ENUM
7446   BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC
7447 ENUMDOC
7448   AArch64 TLS DESC relocation.
7449 ENUM
7450   BFD_RELOC_AARCH64_TLSDESC_ADD_LO12
7451 ENUMDOC
7452   AArch64 TLS DESC relocation.
7453 ENUM
7454   BFD_RELOC_AARCH64_TLSDESC_OFF_G1
7455 ENUMDOC
7456   AArch64 TLS DESC relocation.
7457 ENUM
7458   BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC
7459 ENUMDOC
7460   AArch64 TLS DESC relocation.
7461 ENUM
7462   BFD_RELOC_AARCH64_TLSDESC_LDR
7463 ENUMDOC
7464   AArch64 TLS DESC relocation.
7465 ENUM
7466   BFD_RELOC_AARCH64_TLSDESC_ADD
7467 ENUMDOC
7468   AArch64 TLS DESC relocation.
7469 ENUM
7470   BFD_RELOC_AARCH64_TLSDESC_CALL
7471 ENUMDOC
7472   AArch64 TLS DESC relocation.
7473 ENUM
7474   BFD_RELOC_AARCH64_COPY
7475 ENUMDOC
7476   AArch64 TLS relocation.
7477 ENUM
7478   BFD_RELOC_AARCH64_GLOB_DAT
7479 ENUMDOC
7480   AArch64 TLS relocation.
7481 ENUM
7482   BFD_RELOC_AARCH64_JUMP_SLOT
7483 ENUMDOC
7484   AArch64 TLS relocation.
7485 ENUM
7486   BFD_RELOC_AARCH64_RELATIVE
7487 ENUMDOC
7488   AArch64 TLS relocation.
7489 ENUM
7490   BFD_RELOC_AARCH64_TLS_DTPMOD
7491 ENUMDOC
7492   AArch64 TLS relocation.
7493 ENUM
7494   BFD_RELOC_AARCH64_TLS_DTPREL
7495 ENUMDOC
7496   AArch64 TLS relocation.
7497 ENUM
7498   BFD_RELOC_AARCH64_TLS_TPREL
7499 ENUMDOC
7500   AArch64 TLS relocation.
7501 ENUM
7502   BFD_RELOC_AARCH64_TLSDESC
7503 ENUMDOC
7504   AArch64 TLS relocation.
7505 ENUM
7506   BFD_RELOC_AARCH64_IRELATIVE
7507 ENUMDOC
7508   AArch64 support for STT_GNU_IFUNC.
7509 ENUM
7510   BFD_RELOC_AARCH64_RELOC_END
7511 ENUMDOC
7512   AArch64 pseudo relocation code to mark the end of the AArch64
7513   relocation enumerators that have direct mapping to ELF reloc codes.
7514   There are a few more enumerators after this one; those are mainly
7515   used by the AArch64 assembler for the internal fixup or to select
7516   one of the above enumerators.
7517 ENUM
7518   BFD_RELOC_AARCH64_GAS_INTERNAL_FIXUP
7519 ENUMDOC
7520   AArch64 pseudo relocation code to be used internally by the AArch64
7521   assembler and not (currently) written to any object files.
7522 ENUM
7523   BFD_RELOC_AARCH64_LDST_LO12
7524 ENUMDOC
7525   AArch64 unspecified load/store instruction, holding bits 0 to 11 of the
7526   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
7527 ENUM
7528   BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12
7529 ENUMDOC
7530   AArch64 pseudo relocation code for TLS local dynamic mode.  It's to be
7531   used internally by the AArch64 assembler and not (currently) written to
7532   any object files.
7533 ENUM
7534   BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12_NC
7535 ENUMDOC
7536   Similar as BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12, but no overflow check.
7537 ENUM
7538   BFD_RELOC_AARCH64_TLSLE_LDST_TPREL_LO12
7539 ENUMDOC
7540   AArch64 pseudo relocation code for TLS local exec mode.  It's to be
7541   used internally by the AArch64 assembler and not (currently) written to
7542   any object files.
7543 ENUM
7544   BFD_RELOC_AARCH64_TLSLE_LDST_TPREL_LO12_NC
7545 ENUMDOC
7546   Similar as BFD_RELOC_AARCH64_TLSLE_LDST_TPREL_LO12, but no overflow check.
7547 ENUM
7548   BFD_RELOC_AARCH64_LD_GOT_LO12_NC
7549 ENUMDOC
7550   AArch64 pseudo relocation code to be used internally by the AArch64
7551   assembler and not (currently) written to any object files.
7552 ENUM
7553   BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_LO12_NC
7554 ENUMDOC
7555   AArch64 pseudo relocation code to be used internally by the AArch64
7556   assembler and not (currently) written to any object files.
7557 ENUM
7558   BFD_RELOC_AARCH64_TLSDESC_LD_LO12_NC
7559 ENUMDOC
7560   AArch64 pseudo relocation code to be used internally by the AArch64
7561   assembler and not (currently) written to any object files.
7562 ENUM
7563   BFD_RELOC_TILEPRO_COPY
7564 ENUMX
7565   BFD_RELOC_TILEPRO_GLOB_DAT
7566 ENUMX
7567   BFD_RELOC_TILEPRO_JMP_SLOT
7568 ENUMX
7569   BFD_RELOC_TILEPRO_RELATIVE
7570 ENUMX
7571   BFD_RELOC_TILEPRO_BROFF_X1
7572 ENUMX
7573   BFD_RELOC_TILEPRO_JOFFLONG_X1
7574 ENUMX
7575   BFD_RELOC_TILEPRO_JOFFLONG_X1_PLT
7576 ENUMX
7577   BFD_RELOC_TILEPRO_IMM8_X0
7578 ENUMX
7579   BFD_RELOC_TILEPRO_IMM8_Y0
7580 ENUMX
7581   BFD_RELOC_TILEPRO_IMM8_X1
7582 ENUMX
7583   BFD_RELOC_TILEPRO_IMM8_Y1
7584 ENUMX
7585   BFD_RELOC_TILEPRO_DEST_IMM8_X1
7586 ENUMX
7587   BFD_RELOC_TILEPRO_MT_IMM15_X1
7588 ENUMX
7589   BFD_RELOC_TILEPRO_MF_IMM15_X1
7590 ENUMX
7591   BFD_RELOC_TILEPRO_IMM16_X0
7592 ENUMX
7593   BFD_RELOC_TILEPRO_IMM16_X1
7594 ENUMX
7595   BFD_RELOC_TILEPRO_IMM16_X0_LO
7596 ENUMX
7597   BFD_RELOC_TILEPRO_IMM16_X1_LO
7598 ENUMX
7599   BFD_RELOC_TILEPRO_IMM16_X0_HI
7600 ENUMX
7601   BFD_RELOC_TILEPRO_IMM16_X1_HI
7602 ENUMX
7603   BFD_RELOC_TILEPRO_IMM16_X0_HA
7604 ENUMX
7605   BFD_RELOC_TILEPRO_IMM16_X1_HA
7606 ENUMX
7607   BFD_RELOC_TILEPRO_IMM16_X0_PCREL
7608 ENUMX
7609   BFD_RELOC_TILEPRO_IMM16_X1_PCREL
7610 ENUMX
7611   BFD_RELOC_TILEPRO_IMM16_X0_LO_PCREL
7612 ENUMX
7613   BFD_RELOC_TILEPRO_IMM16_X1_LO_PCREL
7614 ENUMX
7615   BFD_RELOC_TILEPRO_IMM16_X0_HI_PCREL
7616 ENUMX
7617   BFD_RELOC_TILEPRO_IMM16_X1_HI_PCREL
7618 ENUMX
7619   BFD_RELOC_TILEPRO_IMM16_X0_HA_PCREL
7620 ENUMX
7621   BFD_RELOC_TILEPRO_IMM16_X1_HA_PCREL
7622 ENUMX
7623   BFD_RELOC_TILEPRO_IMM16_X0_GOT
7624 ENUMX
7625   BFD_RELOC_TILEPRO_IMM16_X1_GOT
7626 ENUMX
7627   BFD_RELOC_TILEPRO_IMM16_X0_GOT_LO
7628 ENUMX
7629   BFD_RELOC_TILEPRO_IMM16_X1_GOT_LO
7630 ENUMX
7631   BFD_RELOC_TILEPRO_IMM16_X0_GOT_HI
7632 ENUMX
7633   BFD_RELOC_TILEPRO_IMM16_X1_GOT_HI
7634 ENUMX
7635   BFD_RELOC_TILEPRO_IMM16_X0_GOT_HA
7636 ENUMX
7637   BFD_RELOC_TILEPRO_IMM16_X1_GOT_HA
7638 ENUMX
7639   BFD_RELOC_TILEPRO_MMSTART_X0
7640 ENUMX
7641   BFD_RELOC_TILEPRO_MMEND_X0
7642 ENUMX
7643   BFD_RELOC_TILEPRO_MMSTART_X1
7644 ENUMX
7645   BFD_RELOC_TILEPRO_MMEND_X1
7646 ENUMX
7647   BFD_RELOC_TILEPRO_SHAMT_X0
7648 ENUMX
7649   BFD_RELOC_TILEPRO_SHAMT_X1
7650 ENUMX
7651   BFD_RELOC_TILEPRO_SHAMT_Y0
7652 ENUMX
7653   BFD_RELOC_TILEPRO_SHAMT_Y1
7654 ENUMX
7655   BFD_RELOC_TILEPRO_TLS_GD_CALL
7656 ENUMX
7657   BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD
7658 ENUMX
7659   BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD
7660 ENUMX
7661   BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD
7662 ENUMX
7663   BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD
7664 ENUMX
7665   BFD_RELOC_TILEPRO_TLS_IE_LOAD
7666 ENUMX
7667   BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD
7668 ENUMX
7669   BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD
7670 ENUMX
7671   BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO
7672 ENUMX
7673   BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_LO
7674 ENUMX
7675   BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HI
7676 ENUMX
7677   BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HI
7678 ENUMX
7679   BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HA
7680 ENUMX
7681   BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HA
7682 ENUMX
7683   BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE
7684 ENUMX
7685   BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE
7686 ENUMX
7687   BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_LO
7688 ENUMX
7689   BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_LO
7690 ENUMX
7691   BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HI
7692 ENUMX
7693   BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HI
7694 ENUMX
7695   BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HA
7696 ENUMX
7697   BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HA
7698 ENUMX
7699   BFD_RELOC_TILEPRO_TLS_DTPMOD32
7700 ENUMX
7701   BFD_RELOC_TILEPRO_TLS_DTPOFF32
7702 ENUMX
7703   BFD_RELOC_TILEPRO_TLS_TPOFF32
7704 ENUMX
7705   BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE
7706 ENUMX
7707   BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE
7708 ENUMX
7709   BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_LO
7710 ENUMX
7711   BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_LO
7712 ENUMX
7713   BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HI
7714 ENUMX
7715   BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HI
7716 ENUMX
7717   BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HA
7718 ENUMX
7719   BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HA
7720 ENUMDOC
7721   Tilera TILEPro Relocations.
7722 ENUM
7723   BFD_RELOC_TILEGX_HW0
7724 ENUMX
7725   BFD_RELOC_TILEGX_HW1
7726 ENUMX
7727   BFD_RELOC_TILEGX_HW2
7728 ENUMX
7729   BFD_RELOC_TILEGX_HW3
7730 ENUMX
7731   BFD_RELOC_TILEGX_HW0_LAST
7732 ENUMX
7733   BFD_RELOC_TILEGX_HW1_LAST
7734 ENUMX
7735   BFD_RELOC_TILEGX_HW2_LAST
7736 ENUMX
7737   BFD_RELOC_TILEGX_COPY
7738 ENUMX
7739   BFD_RELOC_TILEGX_GLOB_DAT
7740 ENUMX
7741   BFD_RELOC_TILEGX_JMP_SLOT
7742 ENUMX
7743   BFD_RELOC_TILEGX_RELATIVE
7744 ENUMX
7745   BFD_RELOC_TILEGX_BROFF_X1
7746 ENUMX
7747   BFD_RELOC_TILEGX_JUMPOFF_X1
7748 ENUMX
7749   BFD_RELOC_TILEGX_JUMPOFF_X1_PLT
7750 ENUMX
7751   BFD_RELOC_TILEGX_IMM8_X0
7752 ENUMX
7753   BFD_RELOC_TILEGX_IMM8_Y0
7754 ENUMX
7755   BFD_RELOC_TILEGX_IMM8_X1
7756 ENUMX
7757   BFD_RELOC_TILEGX_IMM8_Y1
7758 ENUMX
7759   BFD_RELOC_TILEGX_DEST_IMM8_X1
7760 ENUMX
7761   BFD_RELOC_TILEGX_MT_IMM14_X1
7762 ENUMX
7763   BFD_RELOC_TILEGX_MF_IMM14_X1
7764 ENUMX
7765   BFD_RELOC_TILEGX_MMSTART_X0
7766 ENUMX
7767   BFD_RELOC_TILEGX_MMEND_X0
7768 ENUMX
7769   BFD_RELOC_TILEGX_SHAMT_X0
7770 ENUMX
7771   BFD_RELOC_TILEGX_SHAMT_X1
7772 ENUMX
7773   BFD_RELOC_TILEGX_SHAMT_Y0
7774 ENUMX
7775   BFD_RELOC_TILEGX_SHAMT_Y1
7776 ENUMX
7777   BFD_RELOC_TILEGX_IMM16_X0_HW0
7778 ENUMX
7779   BFD_RELOC_TILEGX_IMM16_X1_HW0
7780 ENUMX
7781   BFD_RELOC_TILEGX_IMM16_X0_HW1
7782 ENUMX
7783   BFD_RELOC_TILEGX_IMM16_X1_HW1
7784 ENUMX
7785   BFD_RELOC_TILEGX_IMM16_X0_HW2
7786 ENUMX
7787   BFD_RELOC_TILEGX_IMM16_X1_HW2
7788 ENUMX
7789   BFD_RELOC_TILEGX_IMM16_X0_HW3
7790 ENUMX
7791   BFD_RELOC_TILEGX_IMM16_X1_HW3
7792 ENUMX
7793   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST
7794 ENUMX
7795   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST
7796 ENUMX
7797   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST
7798 ENUMX
7799   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST
7800 ENUMX
7801   BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST
7802 ENUMX
7803   BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST
7804 ENUMX
7805   BFD_RELOC_TILEGX_IMM16_X0_HW0_PCREL
7806 ENUMX
7807   BFD_RELOC_TILEGX_IMM16_X1_HW0_PCREL
7808 ENUMX
7809   BFD_RELOC_TILEGX_IMM16_X0_HW1_PCREL
7810 ENUMX
7811   BFD_RELOC_TILEGX_IMM16_X1_HW1_PCREL
7812 ENUMX
7813   BFD_RELOC_TILEGX_IMM16_X0_HW2_PCREL
7814 ENUMX
7815   BFD_RELOC_TILEGX_IMM16_X1_HW2_PCREL
7816 ENUMX
7817   BFD_RELOC_TILEGX_IMM16_X0_HW3_PCREL
7818 ENUMX
7819   BFD_RELOC_TILEGX_IMM16_X1_HW3_PCREL
7820 ENUMX
7821   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PCREL
7822 ENUMX
7823   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PCREL
7824 ENUMX
7825   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PCREL
7826 ENUMX
7827   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PCREL
7828 ENUMX
7829   BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PCREL
7830 ENUMX
7831   BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PCREL
7832 ENUMX
7833   BFD_RELOC_TILEGX_IMM16_X0_HW0_GOT
7834 ENUMX
7835   BFD_RELOC_TILEGX_IMM16_X1_HW0_GOT
7836 ENUMX
7837   BFD_RELOC_TILEGX_IMM16_X0_HW0_PLT_PCREL
7838 ENUMX
7839   BFD_RELOC_TILEGX_IMM16_X1_HW0_PLT_PCREL
7840 ENUMX
7841   BFD_RELOC_TILEGX_IMM16_X0_HW1_PLT_PCREL
7842 ENUMX
7843   BFD_RELOC_TILEGX_IMM16_X1_HW1_PLT_PCREL
7844 ENUMX
7845   BFD_RELOC_TILEGX_IMM16_X0_HW2_PLT_PCREL
7846 ENUMX
7847   BFD_RELOC_TILEGX_IMM16_X1_HW2_PLT_PCREL
7848 ENUMX
7849   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_GOT
7850 ENUMX
7851   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_GOT
7852 ENUMX
7853   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_GOT
7854 ENUMX
7855   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_GOT
7856 ENUMX
7857   BFD_RELOC_TILEGX_IMM16_X0_HW3_PLT_PCREL
7858 ENUMX
7859   BFD_RELOC_TILEGX_IMM16_X1_HW3_PLT_PCREL
7860 ENUMX
7861   BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_GD
7862 ENUMX
7863   BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_GD
7864 ENUMX
7865   BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_LE
7866 ENUMX
7867   BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_LE
7868 ENUMX
7869   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
7870 ENUMX
7871   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
7872 ENUMX
7873   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
7874 ENUMX
7875   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
7876 ENUMX
7877   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
7878 ENUMX
7879   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
7880 ENUMX
7881   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
7882 ENUMX
7883   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
7884 ENUMX
7885   BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_IE
7886 ENUMX
7887   BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_IE
7888 ENUMX
7889   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
7890 ENUMX
7891   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
7892 ENUMX
7893   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
7894 ENUMX
7895   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
7896 ENUMX
7897   BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
7898 ENUMX
7899   BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
7900 ENUMX
7901   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
7902 ENUMX
7903   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
7904 ENUMX
7905   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
7906 ENUMX
7907   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
7908 ENUMX
7909   BFD_RELOC_TILEGX_TLS_DTPMOD64
7910 ENUMX
7911   BFD_RELOC_TILEGX_TLS_DTPOFF64
7912 ENUMX
7913   BFD_RELOC_TILEGX_TLS_TPOFF64
7914 ENUMX
7915   BFD_RELOC_TILEGX_TLS_DTPMOD32
7916 ENUMX
7917   BFD_RELOC_TILEGX_TLS_DTPOFF32
7918 ENUMX
7919   BFD_RELOC_TILEGX_TLS_TPOFF32
7920 ENUMX
7921   BFD_RELOC_TILEGX_TLS_GD_CALL
7922 ENUMX
7923   BFD_RELOC_TILEGX_IMM8_X0_TLS_GD_ADD
7924 ENUMX
7925   BFD_RELOC_TILEGX_IMM8_X1_TLS_GD_ADD
7926 ENUMX
7927   BFD_RELOC_TILEGX_IMM8_Y0_TLS_GD_ADD
7928 ENUMX
7929   BFD_RELOC_TILEGX_IMM8_Y1_TLS_GD_ADD
7930 ENUMX
7931   BFD_RELOC_TILEGX_TLS_IE_LOAD
7932 ENUMX
7933   BFD_RELOC_TILEGX_IMM8_X0_TLS_ADD
7934 ENUMX
7935   BFD_RELOC_TILEGX_IMM8_X1_TLS_ADD
7936 ENUMX
7937   BFD_RELOC_TILEGX_IMM8_Y0_TLS_ADD
7938 ENUMX
7939   BFD_RELOC_TILEGX_IMM8_Y1_TLS_ADD
7940 ENUMDOC
7941   Tilera TILE-Gx Relocations.
7942
7943 ENUM
7944   BFD_RELOC_BPF_64
7945 ENUMX
7946   BFD_RELOC_BPF_32
7947 ENUMX
7948   BFD_RELOC_BPF_16
7949 ENUMX
7950   BFD_RELOC_BPF_DISP16
7951 ENUMX
7952   BFD_RELOC_BPF_DISP32
7953 ENUMDOC
7954   Linux eBPF relocations.
7955
7956 ENUM
7957   BFD_RELOC_EPIPHANY_SIMM8
7958 ENUMDOC
7959   Adapteva EPIPHANY - 8 bit signed pc-relative displacement
7960 ENUM
7961   BFD_RELOC_EPIPHANY_SIMM24
7962 ENUMDOC
7963   Adapteva EPIPHANY - 24 bit signed pc-relative displacement
7964 ENUM
7965   BFD_RELOC_EPIPHANY_HIGH
7966 ENUMDOC
7967   Adapteva EPIPHANY - 16 most-significant bits of absolute address
7968 ENUM
7969   BFD_RELOC_EPIPHANY_LOW
7970 ENUMDOC
7971   Adapteva EPIPHANY - 16 least-significant bits of absolute address
7972 ENUM
7973   BFD_RELOC_EPIPHANY_SIMM11
7974 ENUMDOC
7975   Adapteva EPIPHANY - 11 bit signed number - add/sub immediate
7976 ENUM
7977   BFD_RELOC_EPIPHANY_IMM11
7978 ENUMDOC
7979   Adapteva EPIPHANY - 11 bit sign-magnitude number (ld/st displacement)
7980 ENUM
7981   BFD_RELOC_EPIPHANY_IMM8
7982 ENUMDOC
7983   Adapteva EPIPHANY - 8 bit immediate for 16 bit mov instruction.
7984
7985 ENUM
7986   BFD_RELOC_VISIUM_HI16
7987 ENUMX
7988   BFD_RELOC_VISIUM_LO16
7989 ENUMX
7990   BFD_RELOC_VISIUM_IM16
7991 ENUMX
7992   BFD_RELOC_VISIUM_REL16
7993 ENUMX
7994   BFD_RELOC_VISIUM_HI16_PCREL
7995 ENUMX
7996   BFD_RELOC_VISIUM_LO16_PCREL
7997 ENUMX
7998   BFD_RELOC_VISIUM_IM16_PCREL
7999 ENUMDOC
8000   Visium Relocations.
8001
8002 ENUM
8003   BFD_RELOC_WASM32_LEB128
8004 ENUMX
8005   BFD_RELOC_WASM32_LEB128_GOT
8006 ENUMX
8007   BFD_RELOC_WASM32_LEB128_GOT_CODE
8008 ENUMX
8009   BFD_RELOC_WASM32_LEB128_PLT
8010 ENUMX
8011   BFD_RELOC_WASM32_PLT_INDEX
8012 ENUMX
8013   BFD_RELOC_WASM32_ABS32_CODE
8014 ENUMX
8015   BFD_RELOC_WASM32_COPY
8016 ENUMX
8017   BFD_RELOC_WASM32_CODE_POINTER
8018 ENUMX
8019   BFD_RELOC_WASM32_INDEX
8020 ENUMX
8021   BFD_RELOC_WASM32_PLT_SIG
8022 ENUMDOC
8023   WebAssembly relocations.
8024
8025 ENUM
8026   BFD_RELOC_CKCORE_NONE
8027 ENUMX
8028   BFD_RELOC_CKCORE_ADDR32
8029 ENUMX
8030   BFD_RELOC_CKCORE_PCREL_IMM8BY4
8031 ENUMX
8032   BFD_RELOC_CKCORE_PCREL_IMM11BY2
8033 ENUMX
8034   BFD_RELOC_CKCORE_PCREL_IMM4BY2
8035 ENUMX
8036   BFD_RELOC_CKCORE_PCREL32
8037 ENUMX
8038   BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2
8039 ENUMX
8040   BFD_RELOC_CKCORE_GNU_VTINHERIT
8041 ENUMX
8042   BFD_RELOC_CKCORE_GNU_VTENTRY
8043 ENUMX
8044   BFD_RELOC_CKCORE_RELATIVE
8045 ENUMX
8046   BFD_RELOC_CKCORE_COPY
8047 ENUMX
8048   BFD_RELOC_CKCORE_GLOB_DAT
8049 ENUMX
8050   BFD_RELOC_CKCORE_JUMP_SLOT
8051 ENUMX
8052   BFD_RELOC_CKCORE_GOTOFF
8053 ENUMX
8054   BFD_RELOC_CKCORE_GOTPC
8055 ENUMX
8056   BFD_RELOC_CKCORE_GOT32
8057 ENUMX
8058   BFD_RELOC_CKCORE_PLT32
8059 ENUMX
8060   BFD_RELOC_CKCORE_ADDRGOT
8061 ENUMX
8062   BFD_RELOC_CKCORE_ADDRPLT
8063 ENUMX
8064   BFD_RELOC_CKCORE_PCREL_IMM26BY2
8065 ENUMX
8066   BFD_RELOC_CKCORE_PCREL_IMM16BY2
8067 ENUMX
8068   BFD_RELOC_CKCORE_PCREL_IMM16BY4
8069 ENUMX
8070   BFD_RELOC_CKCORE_PCREL_IMM10BY2
8071 ENUMX
8072   BFD_RELOC_CKCORE_PCREL_IMM10BY4
8073 ENUMX
8074   BFD_RELOC_CKCORE_ADDR_HI16
8075 ENUMX
8076   BFD_RELOC_CKCORE_ADDR_LO16
8077 ENUMX
8078   BFD_RELOC_CKCORE_GOTPC_HI16
8079 ENUMX
8080   BFD_RELOC_CKCORE_GOTPC_LO16
8081 ENUMX
8082   BFD_RELOC_CKCORE_GOTOFF_HI16
8083 ENUMX
8084   BFD_RELOC_CKCORE_GOTOFF_LO16
8085 ENUMX
8086   BFD_RELOC_CKCORE_GOT12
8087 ENUMX
8088   BFD_RELOC_CKCORE_GOT_HI16
8089 ENUMX
8090   BFD_RELOC_CKCORE_GOT_LO16
8091 ENUMX
8092   BFD_RELOC_CKCORE_PLT12
8093 ENUMX
8094   BFD_RELOC_CKCORE_PLT_HI16
8095 ENUMX
8096   BFD_RELOC_CKCORE_PLT_LO16
8097 ENUMX
8098   BFD_RELOC_CKCORE_ADDRGOT_HI16
8099 ENUMX
8100   BFD_RELOC_CKCORE_ADDRGOT_LO16
8101 ENUMX
8102   BFD_RELOC_CKCORE_ADDRPLT_HI16
8103 ENUMX
8104   BFD_RELOC_CKCORE_ADDRPLT_LO16
8105 ENUMX
8106   BFD_RELOC_CKCORE_PCREL_JSR_IMM26BY2
8107 ENUMX
8108   BFD_RELOC_CKCORE_TOFFSET_LO16
8109 ENUMX
8110   BFD_RELOC_CKCORE_DOFFSET_LO16
8111 ENUMX
8112   BFD_RELOC_CKCORE_PCREL_IMM18BY2
8113 ENUMX
8114   BFD_RELOC_CKCORE_DOFFSET_IMM18
8115 ENUMX
8116   BFD_RELOC_CKCORE_DOFFSET_IMM18BY2
8117 ENUMX
8118   BFD_RELOC_CKCORE_DOFFSET_IMM18BY4
8119 ENUMX
8120   BFD_RELOC_CKCORE_GOTOFF_IMM18
8121 ENUMX
8122   BFD_RELOC_CKCORE_GOT_IMM18BY4
8123 ENUMX
8124   BFD_RELOC_CKCORE_PLT_IMM18BY4
8125 ENUMX
8126   BFD_RELOC_CKCORE_PCREL_IMM7BY4
8127 ENUMX
8128   BFD_RELOC_CKCORE_TLS_LE32
8129 ENUMX
8130   BFD_RELOC_CKCORE_TLS_IE32
8131 ENUMX
8132   BFD_RELOC_CKCORE_TLS_GD32
8133 ENUMX
8134   BFD_RELOC_CKCORE_TLS_LDM32
8135 ENUMX
8136   BFD_RELOC_CKCORE_TLS_LDO32
8137 ENUMX
8138   BFD_RELOC_CKCORE_TLS_DTPMOD32
8139 ENUMX
8140   BFD_RELOC_CKCORE_TLS_DTPOFF32
8141 ENUMX
8142   BFD_RELOC_CKCORE_TLS_TPOFF32
8143 ENUMX
8144   BFD_RELOC_CKCORE_PCREL_FLRW_IMM8BY4
8145 ENUMX
8146   BFD_RELOC_CKCORE_NOJSRI
8147 ENUMX
8148   BFD_RELOC_CKCORE_CALLGRAPH
8149 ENUMX
8150   BFD_RELOC_CKCORE_IRELATIVE
8151 ENUMX
8152   BFD_RELOC_CKCORE_PCREL_BLOOP_IMM4BY4
8153 ENUMX
8154   BFD_RELOC_CKCORE_PCREL_BLOOP_IMM12BY4
8155 ENUMDOC
8156   C-SKY relocations.
8157
8158 ENUM
8159   BFD_RELOC_S12Z_OPR
8160 ENUMDOC
8161   S12Z relocations.
8162
8163 ENDSENUM
8164   BFD_RELOC_UNUSED
8165 CODE_FRAGMENT
8166 .
8167 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
8168 */
8169
8170 /*
8171 FUNCTION
8172         bfd_reloc_type_lookup
8173         bfd_reloc_name_lookup
8174
8175 SYNOPSIS
8176         reloc_howto_type *bfd_reloc_type_lookup
8177           (bfd *abfd, bfd_reloc_code_real_type code);
8178         reloc_howto_type *bfd_reloc_name_lookup
8179           (bfd *abfd, const char *reloc_name);
8180
8181 DESCRIPTION
8182         Return a pointer to a howto structure which, when
8183         invoked, will perform the relocation @var{code} on data from the
8184         architecture noted.
8185
8186 */
8187
8188 reloc_howto_type *
8189 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
8190 {
8191   return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
8192 }
8193
8194 reloc_howto_type *
8195 bfd_reloc_name_lookup (bfd *abfd, const char *reloc_name)
8196 {
8197   return BFD_SEND (abfd, reloc_name_lookup, (abfd, reloc_name));
8198 }
8199
8200 static reloc_howto_type bfd_howto_32 =
8201 HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_dont, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE);
8202
8203 /*
8204 INTERNAL_FUNCTION
8205         bfd_default_reloc_type_lookup
8206
8207 SYNOPSIS
8208         reloc_howto_type *bfd_default_reloc_type_lookup
8209           (bfd *abfd, bfd_reloc_code_real_type  code);
8210
8211 DESCRIPTION
8212         Provides a default relocation lookup routine for any architecture.
8213
8214 */
8215
8216 reloc_howto_type *
8217 bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
8218 {
8219   /* Very limited support is provided for relocs in generic targets
8220      such as elf32-little.  FIXME: Should we always return NULL?  */
8221   if (code == BFD_RELOC_CTOR
8222       && bfd_arch_bits_per_address (abfd) == 32)
8223     return &bfd_howto_32;
8224   return NULL;
8225 }
8226
8227 /*
8228 FUNCTION
8229         bfd_get_reloc_code_name
8230
8231 SYNOPSIS
8232         const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
8233
8234 DESCRIPTION
8235         Provides a printable name for the supplied relocation code.
8236         Useful mainly for printing error messages.
8237 */
8238
8239 const char *
8240 bfd_get_reloc_code_name (bfd_reloc_code_real_type code)
8241 {
8242   if (code > BFD_RELOC_UNUSED)
8243     return 0;
8244   return bfd_reloc_code_real_names[code];
8245 }
8246
8247 /*
8248 INTERNAL_FUNCTION
8249         bfd_generic_relax_section
8250
8251 SYNOPSIS
8252         bfd_boolean bfd_generic_relax_section
8253           (bfd *abfd,
8254            asection *section,
8255            struct bfd_link_info *,
8256            bfd_boolean *);
8257
8258 DESCRIPTION
8259         Provides default handling for relaxing for back ends which
8260         don't do relaxing.
8261 */
8262
8263 bfd_boolean
8264 bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
8265                            asection *section ATTRIBUTE_UNUSED,
8266                            struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
8267                            bfd_boolean *again)
8268 {
8269   if (bfd_link_relocatable (link_info))
8270     (*link_info->callbacks->einfo)
8271       (_("%P%F: --relax and -r may not be used together\n"));
8272
8273   *again = FALSE;
8274   return TRUE;
8275 }
8276
8277 /*
8278 INTERNAL_FUNCTION
8279         bfd_generic_gc_sections
8280
8281 SYNOPSIS
8282         bfd_boolean bfd_generic_gc_sections
8283           (bfd *, struct bfd_link_info *);
8284
8285 DESCRIPTION
8286         Provides default handling for relaxing for back ends which
8287         don't do section gc -- i.e., does nothing.
8288 */
8289
8290 bfd_boolean
8291 bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED,
8292                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
8293 {
8294   return TRUE;
8295 }
8296
8297 /*
8298 INTERNAL_FUNCTION
8299         bfd_generic_lookup_section_flags
8300
8301 SYNOPSIS
8302         bfd_boolean bfd_generic_lookup_section_flags
8303           (struct bfd_link_info *, struct flag_info *, asection *);
8304
8305 DESCRIPTION
8306         Provides default handling for section flags lookup
8307         -- i.e., does nothing.
8308         Returns FALSE if the section should be omitted, otherwise TRUE.
8309 */
8310
8311 bfd_boolean
8312 bfd_generic_lookup_section_flags (struct bfd_link_info *info ATTRIBUTE_UNUSED,
8313                                   struct flag_info *flaginfo,
8314                                   asection *section ATTRIBUTE_UNUSED)
8315 {
8316   if (flaginfo != NULL)
8317     {
8318       _bfd_error_handler (_("INPUT_SECTION_FLAGS are not supported"));
8319       return FALSE;
8320     }
8321   return TRUE;
8322 }
8323
8324 /*
8325 INTERNAL_FUNCTION
8326         bfd_generic_merge_sections
8327
8328 SYNOPSIS
8329         bfd_boolean bfd_generic_merge_sections
8330           (bfd *, struct bfd_link_info *);
8331
8332 DESCRIPTION
8333         Provides default handling for SEC_MERGE section merging for back ends
8334         which don't have SEC_MERGE support -- i.e., does nothing.
8335 */
8336
8337 bfd_boolean
8338 bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED,
8339                             struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
8340 {
8341   return TRUE;
8342 }
8343
8344 /*
8345 INTERNAL_FUNCTION
8346         bfd_generic_get_relocated_section_contents
8347
8348 SYNOPSIS
8349         bfd_byte *bfd_generic_get_relocated_section_contents
8350           (bfd *abfd,
8351            struct bfd_link_info *link_info,
8352            struct bfd_link_order *link_order,
8353            bfd_byte *data,
8354            bfd_boolean relocatable,
8355            asymbol **symbols);
8356
8357 DESCRIPTION
8358         Provides default handling of relocation effort for back ends
8359         which can't be bothered to do it efficiently.
8360
8361 */
8362
8363 bfd_byte *
8364 bfd_generic_get_relocated_section_contents (bfd *abfd,
8365                                             struct bfd_link_info *link_info,
8366                                             struct bfd_link_order *link_order,
8367                                             bfd_byte *data,
8368                                             bfd_boolean relocatable,
8369                                             asymbol **symbols)
8370 {
8371   bfd *input_bfd = link_order->u.indirect.section->owner;
8372   asection *input_section = link_order->u.indirect.section;
8373   long reloc_size;
8374   arelent **reloc_vector;
8375   long reloc_count;
8376
8377   reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
8378   if (reloc_size < 0)
8379     return NULL;
8380
8381   /* Read in the section.  */
8382   if (!bfd_get_full_section_contents (input_bfd, input_section, &data))
8383     return NULL;
8384
8385   if (data == NULL)
8386     return NULL;
8387
8388   if (reloc_size == 0)
8389     return data;
8390
8391   reloc_vector = (arelent **) bfd_malloc (reloc_size);
8392   if (reloc_vector == NULL)
8393     return NULL;
8394
8395   reloc_count = bfd_canonicalize_reloc (input_bfd,
8396                                         input_section,
8397                                         reloc_vector,
8398                                         symbols);
8399   if (reloc_count < 0)
8400     goto error_return;
8401
8402   if (reloc_count > 0)
8403     {
8404       arelent **parent;
8405
8406       for (parent = reloc_vector; *parent != NULL; parent++)
8407         {
8408           char *error_message = NULL;
8409           asymbol *symbol;
8410           bfd_reloc_status_type r;
8411
8412           symbol = *(*parent)->sym_ptr_ptr;
8413           /* PR ld/19628: A specially crafted input file
8414              can result in a NULL symbol pointer here.  */
8415           if (symbol == NULL)
8416             {
8417               link_info->callbacks->einfo
8418                 /* xgettext:c-format */
8419                 (_("%X%P: %pB(%pA): error: relocation for offset %V has no value\n"),
8420                  abfd, input_section, (* parent)->address);
8421               goto error_return;
8422             }
8423
8424           /* Zap reloc field when the symbol is from a discarded
8425              section, ignoring any addend.  Do the same when called
8426              from bfd_simple_get_relocated_section_contents for
8427              undefined symbols in debug sections.  This is to keep
8428              debug info reasonably sane, in particular so that
8429              DW_FORM_ref_addr to another file's .debug_info isn't
8430              confused with an offset into the current file's
8431              .debug_info.  */
8432           if ((symbol->section != NULL && discarded_section (symbol->section))
8433               || (symbol->section == bfd_und_section_ptr
8434                   && (input_section->flags & SEC_DEBUGGING) != 0
8435                   && link_info->input_bfds == link_info->output_bfd))
8436             {
8437               bfd_vma off;
8438               static reloc_howto_type none_howto
8439                 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
8440                          "unused", FALSE, 0, 0, FALSE);
8441
8442               off = ((*parent)->address
8443                      * bfd_octets_per_byte (input_bfd, input_section));
8444               _bfd_clear_contents ((*parent)->howto, input_bfd,
8445                                    input_section, data, off);
8446               (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
8447               (*parent)->addend = 0;
8448               (*parent)->howto = &none_howto;
8449               r = bfd_reloc_ok;
8450             }
8451           else
8452             r = bfd_perform_relocation (input_bfd,
8453                                         *parent,
8454                                         data,
8455                                         input_section,
8456                                         relocatable ? abfd : NULL,
8457                                         &error_message);
8458
8459           if (relocatable)
8460             {
8461               asection *os = input_section->output_section;
8462
8463               /* A partial link, so keep the relocs.  */
8464               os->orelocation[os->reloc_count] = *parent;
8465               os->reloc_count++;
8466             }
8467
8468           if (r != bfd_reloc_ok)
8469             {
8470               switch (r)
8471                 {
8472                 case bfd_reloc_undefined:
8473                   (*link_info->callbacks->undefined_symbol)
8474                     (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8475                      input_bfd, input_section, (*parent)->address, TRUE);
8476                   break;
8477                 case bfd_reloc_dangerous:
8478                   BFD_ASSERT (error_message != NULL);
8479                   (*link_info->callbacks->reloc_dangerous)
8480                     (link_info, error_message,
8481                      input_bfd, input_section, (*parent)->address);
8482                   break;
8483                 case bfd_reloc_overflow:
8484                   (*link_info->callbacks->reloc_overflow)
8485                     (link_info, NULL,
8486                      bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8487                      (*parent)->howto->name, (*parent)->addend,
8488                      input_bfd, input_section, (*parent)->address);
8489                   break;
8490                 case bfd_reloc_outofrange:
8491                   /* PR ld/13730:
8492                      This error can result when processing some partially
8493                      complete binaries.  Do not abort, but issue an error
8494                      message instead.  */
8495                   link_info->callbacks->einfo
8496                     /* xgettext:c-format */
8497                     (_("%X%P: %pB(%pA): relocation \"%pR\" goes out of range\n"),
8498                      abfd, input_section, * parent);
8499                   goto error_return;
8500
8501                 case bfd_reloc_notsupported:
8502                   /* PR ld/17512
8503                      This error can result when processing a corrupt binary.
8504                      Do not abort.  Issue an error message instead.  */
8505                   link_info->callbacks->einfo
8506                     /* xgettext:c-format */
8507                     (_("%X%P: %pB(%pA): relocation \"%pR\" is not supported\n"),
8508                      abfd, input_section, * parent);
8509                   goto error_return;
8510
8511                 default:
8512                   /* PR 17512; file: 90c2a92e.
8513                      Report unexpected results, without aborting.  */
8514                   link_info->callbacks->einfo
8515                     /* xgettext:c-format */
8516                     (_("%X%P: %pB(%pA): relocation \"%pR\" returns an unrecognized value %x\n"),
8517                      abfd, input_section, * parent, r);
8518                   break;
8519                 }
8520
8521             }
8522         }
8523     }
8524
8525   free (reloc_vector);
8526   return data;
8527
8528  error_return:
8529   free (reloc_vector);
8530   return NULL;
8531 }
8532
8533 /*
8534 INTERNAL_FUNCTION
8535         _bfd_generic_set_reloc
8536
8537 SYNOPSIS
8538         void _bfd_generic_set_reloc
8539           (bfd *abfd,
8540            sec_ptr section,
8541            arelent **relptr,
8542            unsigned int count);
8543
8544 DESCRIPTION
8545         Installs a new set of internal relocations in SECTION.
8546 */
8547
8548 void
8549 _bfd_generic_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
8550                         sec_ptr section,
8551                         arelent **relptr,
8552                         unsigned int count)
8553 {
8554   section->orelocation = relptr;
8555   section->reloc_count = count;
8556 }
8557
8558 /*
8559 INTERNAL_FUNCTION
8560         _bfd_unrecognized_reloc
8561
8562 SYNOPSIS
8563         bfd_boolean _bfd_unrecognized_reloc
8564           (bfd * abfd,
8565            sec_ptr section,
8566            unsigned int r_type);
8567
8568 DESCRIPTION
8569         Reports an unrecognized reloc.
8570         Written as a function in order to reduce code duplication.
8571         Returns FALSE so that it can be called from a return statement.
8572 */
8573
8574 bfd_boolean
8575 _bfd_unrecognized_reloc (bfd * abfd, sec_ptr section, unsigned int r_type)
8576 {
8577    /* xgettext:c-format */
8578   _bfd_error_handler (_("%pB: unrecognized relocation type %#x in section `%pA'"),
8579                       abfd, r_type, section);
8580
8581   /* PR 21803: Suggest the most likely cause of this error.  */
8582   _bfd_error_handler (_("is this version of the linker - %s - out of date ?"),
8583                       BFD_VERSION_STRING);
8584
8585   bfd_set_error (bfd_error_bad_value);
8586   return FALSE;
8587 }
8588
8589 reloc_howto_type *
8590 _bfd_norelocs_bfd_reloc_type_lookup
8591     (bfd *abfd,
8592      bfd_reloc_code_real_type code ATTRIBUTE_UNUSED)
8593 {
8594   return (reloc_howto_type *) _bfd_ptr_bfd_null_error (abfd);
8595 }
8596
8597 reloc_howto_type *
8598 _bfd_norelocs_bfd_reloc_name_lookup (bfd *abfd,
8599                                      const char *reloc_name ATTRIBUTE_UNUSED)
8600 {
8601   return (reloc_howto_type *) _bfd_ptr_bfd_null_error (abfd);
8602 }
8603
8604 long
8605 _bfd_nodynamic_canonicalize_dynamic_reloc (bfd *abfd,
8606                                            arelent **relp ATTRIBUTE_UNUSED,
8607                                            asymbol **symp ATTRIBUTE_UNUSED)
8608 {
8609   return _bfd_long_bfd_n1_error (abfd);
8610 }