bfd/reloc.c

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