bfd/reloc.c

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