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
6790 ENUM
6791   BFD_RELOC_AARCH64_RELOC_START
6792 ENUMDOC
6793   AArch64 pseudo relocation code to mark the start of the AArch64
6794   relocation enumerators.  N.B. the order of the enumerators is
6795   important as several tables in the AArch64 bfd backend are indexed
6796   by these enumerators; make sure they are all synced.
6797 ENUM
6798   BFD_RELOC_AARCH64_NULL
6799 ENUMDOC
6800   Deprecated AArch64 null relocation code.
6801 ENUM
6802   BFD_RELOC_AARCH64_NONE
6803 ENUMDOC
6804   AArch64 null relocation code.
6805 ENUM
6806   BFD_RELOC_AARCH64_64
6807 ENUMX
6808   BFD_RELOC_AARCH64_32
6809 ENUMX
6810   BFD_RELOC_AARCH64_16
6811 ENUMDOC
6812   Basic absolute relocations of N bits.  These are equivalent to
6813 BFD_RELOC_N and they were added to assist the indexing of the howto
6814 table.
6815 ENUM
6816   BFD_RELOC_AARCH64_64_PCREL
6817 ENUMX
6818   BFD_RELOC_AARCH64_32_PCREL
6819 ENUMX
6820   BFD_RELOC_AARCH64_16_PCREL
6821 ENUMDOC
6822   PC-relative relocations.  These are equivalent to BFD_RELOC_N_PCREL
6823 and they were added to assist the indexing of the howto table.
6824 ENUM
6825   BFD_RELOC_AARCH64_MOVW_G0
6826 ENUMDOC
6827   AArch64 MOV[NZK] instruction with most significant bits 0 to 15
6828   of an unsigned address/value.
6829 ENUM
6830   BFD_RELOC_AARCH64_MOVW_G0_NC
6831 ENUMDOC
6832   AArch64 MOV[NZK] instruction with less significant bits 0 to 15 of
6833   an address/value.  No overflow checking.
6834 ENUM
6835   BFD_RELOC_AARCH64_MOVW_G1
6836 ENUMDOC
6837   AArch64 MOV[NZK] instruction with most significant bits 16 to 31
6838   of an unsigned address/value.
6839 ENUM
6840   BFD_RELOC_AARCH64_MOVW_G1_NC
6841 ENUMDOC
6842   AArch64 MOV[NZK] instruction with less significant bits 16 to 31
6843   of an address/value.  No overflow checking.
6844 ENUM
6845   BFD_RELOC_AARCH64_MOVW_G2
6846 ENUMDOC
6847   AArch64 MOV[NZK] instruction with most significant bits 32 to 47
6848   of an unsigned address/value.
6849 ENUM
6850   BFD_RELOC_AARCH64_MOVW_G2_NC
6851 ENUMDOC
6852   AArch64 MOV[NZK] instruction with less significant bits 32 to 47
6853   of an address/value.  No overflow checking.
6854 ENUM
6855   BFD_RELOC_AARCH64_MOVW_G3
6856 ENUMDOC
6857   AArch64 MOV[NZK] instruction with most signficant bits 48 to 64
6858   of a signed or unsigned address/value.
6859 ENUM
6860   BFD_RELOC_AARCH64_MOVW_G0_S
6861 ENUMDOC
6862   AArch64 MOV[NZ] instruction with most significant bits 0 to 15
6863   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
6864   value's sign.
6865 ENUM
6866   BFD_RELOC_AARCH64_MOVW_G1_S
6867 ENUMDOC
6868   AArch64 MOV[NZ] instruction with most significant bits 16 to 31
6869   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
6870   value's sign.
6871 ENUM
6872   BFD_RELOC_AARCH64_MOVW_G2_S
6873 ENUMDOC
6874   AArch64 MOV[NZ] instruction with most significant bits 32 to 47
6875   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
6876   value's sign.
6877 ENUM
6878   BFD_RELOC_AARCH64_MOVW_PREL_G0
6879 ENUMDOC
6880   AArch64 MOV[NZ] instruction with most significant bits 0 to 15
6881   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
6882   value's sign.
6883 ENUM
6884   BFD_RELOC_AARCH64_MOVW_PREL_G0_NC
6885 ENUMDOC
6886   AArch64 MOV[NZ] instruction with most significant bits 0 to 15
6887   of a signed value.  Changes instruction to MOVZ or MOVN depending on the
6888   value's sign.
6889 ENUM
6890   BFD_RELOC_AARCH64_MOVW_PREL_G1
6891 ENUMDOC
6892   AArch64 MOVK instruction with most significant bits 16 to 31
6893   of a signed value.
6894 ENUM
6895   BFD_RELOC_AARCH64_MOVW_PREL_G1_NC
6896 ENUMDOC
6897   AArch64 MOVK instruction with most significant bits 16 to 31
6898   of a signed value.
6899 ENUM
6900   BFD_RELOC_AARCH64_MOVW_PREL_G2
6901 ENUMDOC
6902   AArch64 MOVK instruction with most significant bits 32 to 47
6903   of a signed value.
6904 ENUM
6905   BFD_RELOC_AARCH64_MOVW_PREL_G2_NC
6906 ENUMDOC
6907   AArch64 MOVK instruction with most significant bits 32 to 47
6908   of a signed value.
6909 ENUM
6910   BFD_RELOC_AARCH64_MOVW_PREL_G3
6911 ENUMDOC
6912   AArch64 MOVK instruction with most significant bits 47 to 63
6913   of a signed value.
6914 ENUM
6915   BFD_RELOC_AARCH64_LD_LO19_PCREL
6916 ENUMDOC
6917   AArch64 Load Literal instruction, holding a 19 bit pc-relative word
6918   offset.  The lowest two bits must be zero and are not stored in the
6919   instruction, giving a 21 bit signed byte offset.
6920 ENUM
6921   BFD_RELOC_AARCH64_ADR_LO21_PCREL
6922 ENUMDOC
6923   AArch64 ADR instruction, holding a simple 21 bit pc-relative byte offset.
6924 ENUM
6925   BFD_RELOC_AARCH64_ADR_HI21_PCREL
6926 ENUMDOC
6927   AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page
6928   offset, giving a 4KB aligned page base address.
6929 ENUM
6930   BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL
6931 ENUMDOC
6932   AArch64 ADRP instruction, with bits 12 to 32 of a pc-relative page
6933   offset, giving a 4KB aligned page base address, but with no overflow
6934   checking.
6935 ENUM
6936   BFD_RELOC_AARCH64_ADD_LO12
6937 ENUMDOC
6938   AArch64 ADD immediate instruction, holding bits 0 to 11 of the address.
6939   Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6940 ENUM
6941   BFD_RELOC_AARCH64_LDST8_LO12
6942 ENUMDOC
6943   AArch64 8-bit load/store instruction, holding bits 0 to 11 of the
6944   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6945 ENUM
6946   BFD_RELOC_AARCH64_TSTBR14
6947 ENUMDOC
6948   AArch64 14 bit pc-relative test bit and branch.
6949   The lowest two bits must be zero and are not stored in the instruction,
6950   giving a 16 bit signed byte offset.
6951 ENUM
6952   BFD_RELOC_AARCH64_BRANCH19
6953 ENUMDOC
6954   AArch64 19 bit pc-relative conditional branch and compare & branch.
6955   The lowest two bits must be zero and are not stored in the instruction,
6956   giving a 21 bit signed byte offset.
6957 ENUM
6958   BFD_RELOC_AARCH64_JUMP26
6959 ENUMDOC
6960   AArch64 26 bit pc-relative unconditional branch.
6961   The lowest two bits must be zero and are not stored in the instruction,
6962   giving a 28 bit signed byte offset.
6963 ENUM
6964   BFD_RELOC_AARCH64_CALL26
6965 ENUMDOC
6966   AArch64 26 bit pc-relative unconditional branch and link.
6967   The lowest two bits must be zero and are not stored in the instruction,
6968   giving a 28 bit signed byte offset.
6969 ENUM
6970   BFD_RELOC_AARCH64_LDST16_LO12
6971 ENUMDOC
6972   AArch64 16-bit load/store instruction, holding bits 0 to 11 of the
6973   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6974 ENUM
6975   BFD_RELOC_AARCH64_LDST32_LO12
6976 ENUMDOC
6977   AArch64 32-bit load/store instruction, holding bits 0 to 11 of the
6978   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6979 ENUM
6980   BFD_RELOC_AARCH64_LDST64_LO12
6981 ENUMDOC
6982   AArch64 64-bit load/store instruction, holding bits 0 to 11 of the
6983   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6984 ENUM
6985   BFD_RELOC_AARCH64_LDST128_LO12
6986 ENUMDOC
6987   AArch64 128-bit load/store instruction, holding bits 0 to 11 of the
6988   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
6989 ENUM
6990   BFD_RELOC_AARCH64_GOT_LD_PREL19
6991 ENUMDOC
6992   AArch64 Load Literal instruction, holding a 19 bit PC relative word
6993   offset of the global offset table entry for a symbol.  The lowest two
6994   bits must be zero and are not stored in the instruction, giving a 21
6995   bit signed byte offset.  This relocation type requires signed overflow
6996   checking.
6997 ENUM
6998   BFD_RELOC_AARCH64_ADR_GOT_PAGE
6999 ENUMDOC
7000   Get to the page base of the global offset table entry for a symbol as
7001   part of an ADRP instruction using a 21 bit PC relative value.Used in
7002   conjunction with BFD_RELOC_AARCH64_LD64_GOT_LO12_NC.
7003 ENUM
7004   BFD_RELOC_AARCH64_LD64_GOT_LO12_NC
7005 ENUMDOC
7006   Unsigned 12 bit byte offset for 64 bit load/store from the page of
7007   the GOT entry for this symbol.  Used in conjunction with
7008   BFD_RELOC_AARCH64_ADR_GOT_PAGE.  Valid in LP64 ABI only.
7009 ENUM
7010   BFD_RELOC_AARCH64_LD32_GOT_LO12_NC
7011 ENUMDOC
7012   Unsigned 12 bit byte offset for 32 bit load/store from the page of
7013   the GOT entry for this symbol.  Used in conjunction with
7014   BFD_RELOC_AARCH64_ADR_GOT_PAGE.  Valid in ILP32 ABI only.
7015  ENUM
7016   BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC
7017 ENUMDOC
7018   Unsigned 16 bit byte offset for 64 bit load/store from the GOT entry
7019   for this symbol.  Valid in LP64 ABI only.
7020 ENUM
7021   BFD_RELOC_AARCH64_MOVW_GOTOFF_G1
7022 ENUMDOC
7023   Unsigned 16 bit byte higher offset for 64 bit load/store from the GOT entry
7024   for this symbol.  Valid in LP64 ABI only.
7025 ENUM
7026   BFD_RELOC_AARCH64_LD64_GOTOFF_LO15
7027 ENUMDOC
7028   Unsigned 15 bit byte offset for 64 bit load/store from the page of
7029   the GOT entry for this symbol.  Valid in LP64 ABI only.
7030 ENUM
7031   BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14
7032 ENUMDOC
7033   Scaled 14 bit byte offset to the page base of the global offset table.
7034 ENUM
7035   BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15
7036 ENUMDOC
7037   Scaled 15 bit byte offset to the page base of the global offset table.
7038 ENUM
7039   BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21
7040 ENUMDOC
7041   Get to the page base of the global offset table entry for a symbols
7042   tls_index structure as part of an adrp instruction using a 21 bit PC
7043   relative value.  Used in conjunction with
7044   BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC.
7045 ENUM
7046   BFD_RELOC_AARCH64_TLSGD_ADR_PREL21
7047 ENUMDOC
7048   AArch64 TLS General Dynamic
7049 ENUM
7050   BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC
7051 ENUMDOC
7052   Unsigned 12 bit byte offset to global offset table entry for a symbols
7053   tls_index structure.  Used in conjunction with
7054   BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21.
7055 ENUM
7056   BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC
7057 ENUMDOC
7058   AArch64 TLS General Dynamic relocation.
7059 ENUM
7060   BFD_RELOC_AARCH64_TLSGD_MOVW_G1
7061 ENUMDOC
7062   AArch64 TLS General Dynamic relocation.
7063 ENUM
7064   BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21
7065 ENUMDOC
7066   AArch64 TLS INITIAL EXEC relocation.
7067 ENUM
7068   BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC
7069 ENUMDOC
7070   AArch64 TLS INITIAL EXEC relocation.
7071 ENUM
7072   BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC
7073 ENUMDOC
7074   AArch64 TLS INITIAL EXEC relocation.
7075 ENUM
7076   BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19
7077 ENUMDOC
7078   AArch64 TLS INITIAL EXEC relocation.
7079 ENUM
7080   BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC
7081 ENUMDOC
7082   AArch64 TLS INITIAL EXEC relocation.
7083 ENUM
7084   BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1
7085 ENUMDOC
7086   AArch64 TLS INITIAL EXEC relocation.
7087 ENUM
7088   BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_HI12
7089 ENUMDOC
7090   bit[23:12] of byte offset to module TLS base address.
7091 ENUM
7092   BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12
7093 ENUMDOC
7094   Unsigned 12 bit byte offset to module TLS base address.
7095 ENUM
7096   BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12_NC
7097 ENUMDOC
7098   No overflow check version of BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12.
7099 ENUM
7100   BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC
7101 ENUMDOC
7102   Unsigned 12 bit byte offset to global offset table entry for a symbols
7103   tls_index structure.  Used in conjunction with
7104   BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21.
7105 ENUM
7106   BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21
7107 ENUMDOC
7108   GOT entry page address for AArch64 TLS Local Dynamic, used with ADRP
7109   instruction.
7110 ENUM
7111   BFD_RELOC_AARCH64_TLSLD_ADR_PREL21
7112 ENUMDOC
7113   GOT entry address for AArch64 TLS Local Dynamic, used with ADR instruction.
7114 ENUM
7115   BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12
7116 ENUMDOC
7117   bit[11:1] of byte offset to module TLS base address, encoded in ldst
7118   instructions.
7119 ENUM
7120   BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC
7121 ENUMDOC
7122   Similar as BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12, but no overflow check.
7123 ENUM
7124   BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12
7125 ENUMDOC
7126   bit[11:2] of byte offset to module TLS base address, encoded in ldst
7127   instructions.
7128 ENUM
7129   BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC
7130 ENUMDOC
7131   Similar as BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12, but no overflow check.
7132 ENUM
7133   BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12
7134 ENUMDOC
7135   bit[11:3] of byte offset to module TLS base address, encoded in ldst
7136   instructions.
7137 ENUM
7138   BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC
7139 ENUMDOC
7140   Similar as BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12, but no overflow check.
7141 ENUM
7142   BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12
7143 ENUMDOC
7144   bit[11:0] of byte offset to module TLS base address, encoded in ldst
7145   instructions.
7146 ENUM
7147   BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC
7148 ENUMDOC
7149   Similar as BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12, but no overflow check.
7150 ENUM
7151   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0
7152 ENUMDOC
7153   bit[15:0] of byte offset to module TLS base address.
7154 ENUM
7155   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0_NC
7156 ENUMDOC
7157   No overflow check version of BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0
7158 ENUM
7159   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1
7160 ENUMDOC
7161   bit[31:16] of byte offset to module TLS base address.
7162 ENUM
7163   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1_NC
7164 ENUMDOC
7165   No overflow check version of BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1
7166 ENUM
7167   BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G2
7168 ENUMDOC
7169   bit[47:32] of byte offset to module TLS base address.
7170 ENUM
7171   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2
7172 ENUMDOC
7173   AArch64 TLS LOCAL EXEC relocation.
7174 ENUM
7175   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1
7176 ENUMDOC
7177   AArch64 TLS LOCAL EXEC relocation.
7178 ENUM
7179   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC
7180 ENUMDOC
7181   AArch64 TLS LOCAL EXEC relocation.
7182 ENUM
7183   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0
7184 ENUMDOC
7185   AArch64 TLS LOCAL EXEC relocation.
7186 ENUM
7187   BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC
7188 ENUMDOC
7189   AArch64 TLS LOCAL EXEC relocation.
7190 ENUM
7191   BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12
7192 ENUMDOC
7193   AArch64 TLS LOCAL EXEC relocation.
7194 ENUM
7195   BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12
7196 ENUMDOC
7197   AArch64 TLS LOCAL EXEC relocation.
7198 ENUM
7199   BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC
7200 ENUMDOC
7201   AArch64 TLS LOCAL EXEC relocation.
7202 ENUM
7203   BFD_RELOC_AARCH64_TLSLE_LDST16_TPREL_LO12
7204 ENUMDOC
7205   bit[11:1] of byte offset to module TLS base address, encoded in ldst
7206   instructions.
7207 ENUM
7208   BFD_RELOC_AARCH64_TLSLE_LDST16_TPREL_LO12_NC
7209 ENUMDOC
7210   Similar as BFD_RELOC_AARCH64_TLSLE_LDST16_TPREL_LO12, but no overflow check.
7211 ENUM
7212   BFD_RELOC_AARCH64_TLSLE_LDST32_TPREL_LO12
7213 ENUMDOC
7214   bit[11:2] of byte offset to module TLS base address, encoded in ldst
7215   instructions.
7216 ENUM
7217   BFD_RELOC_AARCH64_TLSLE_LDST32_TPREL_LO12_NC
7218 ENUMDOC
7219   Similar as BFD_RELOC_AARCH64_TLSLE_LDST32_TPREL_LO12, but no overflow check.
7220 ENUM
7221   BFD_RELOC_AARCH64_TLSLE_LDST64_TPREL_LO12
7222 ENUMDOC
7223   bit[11:3] of byte offset to module TLS base address, encoded in ldst
7224   instructions.
7225 ENUM
7226   BFD_RELOC_AARCH64_TLSLE_LDST64_TPREL_LO12_NC
7227 ENUMDOC
7228   Similar as BFD_RELOC_AARCH64_TLSLE_LDST64_TPREL_LO12, but no overflow check.
7229 ENUM
7230   BFD_RELOC_AARCH64_TLSLE_LDST8_TPREL_LO12
7231 ENUMDOC
7232   bit[11:0] of byte offset to module TLS base address, encoded in ldst
7233   instructions.
7234 ENUM
7235   BFD_RELOC_AARCH64_TLSLE_LDST8_TPREL_LO12_NC
7236 ENUMDOC
7237   Similar as BFD_RELOC_AARCH64_TLSLE_LDST8_TPREL_LO12, but no overflow check.
7238 ENUM
7239   BFD_RELOC_AARCH64_TLSDESC_LD_PREL19
7240 ENUMDOC
7241   AArch64 TLS DESC relocation.
7242 ENUM
7243   BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21
7244 ENUMDOC
7245   AArch64 TLS DESC relocation.
7246 ENUM
7247   BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21
7248 ENUMDOC
7249   AArch64 TLS DESC relocation.
7250 ENUM
7251   BFD_RELOC_AARCH64_TLSDESC_LD64_LO12
7252 ENUMDOC
7253   AArch64 TLS DESC relocation.
7254 ENUM
7255   BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC
7256 ENUMDOC
7257   AArch64 TLS DESC relocation.
7258 ENUM
7259   BFD_RELOC_AARCH64_TLSDESC_ADD_LO12
7260 ENUMDOC
7261   AArch64 TLS DESC relocation.
7262 ENUM
7263   BFD_RELOC_AARCH64_TLSDESC_OFF_G1
7264 ENUMDOC
7265   AArch64 TLS DESC relocation.
7266 ENUM
7267   BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC
7268 ENUMDOC
7269   AArch64 TLS DESC relocation.
7270 ENUM
7271   BFD_RELOC_AARCH64_TLSDESC_LDR
7272 ENUMDOC
7273   AArch64 TLS DESC relocation.
7274 ENUM
7275   BFD_RELOC_AARCH64_TLSDESC_ADD
7276 ENUMDOC
7277   AArch64 TLS DESC relocation.
7278 ENUM
7279   BFD_RELOC_AARCH64_TLSDESC_CALL
7280 ENUMDOC
7281   AArch64 TLS DESC relocation.
7282 ENUM
7283   BFD_RELOC_AARCH64_COPY
7284 ENUMDOC
7285   AArch64 TLS relocation.
7286 ENUM
7287   BFD_RELOC_AARCH64_GLOB_DAT
7288 ENUMDOC
7289   AArch64 TLS relocation.
7290 ENUM
7291   BFD_RELOC_AARCH64_JUMP_SLOT
7292 ENUMDOC
7293   AArch64 TLS relocation.
7294 ENUM
7295   BFD_RELOC_AARCH64_RELATIVE
7296 ENUMDOC
7297   AArch64 TLS relocation.
7298 ENUM
7299   BFD_RELOC_AARCH64_TLS_DTPMOD
7300 ENUMDOC
7301   AArch64 TLS relocation.
7302 ENUM
7303   BFD_RELOC_AARCH64_TLS_DTPREL
7304 ENUMDOC
7305   AArch64 TLS relocation.
7306 ENUM
7307   BFD_RELOC_AARCH64_TLS_TPREL
7308 ENUMDOC
7309   AArch64 TLS relocation.
7310 ENUM
7311   BFD_RELOC_AARCH64_TLSDESC
7312 ENUMDOC
7313   AArch64 TLS relocation.
7314 ENUM
7315   BFD_RELOC_AARCH64_IRELATIVE
7316 ENUMDOC
7317   AArch64 support for STT_GNU_IFUNC.
7318 ENUM
7319   BFD_RELOC_AARCH64_RELOC_END
7320 ENUMDOC
7321   AArch64 pseudo relocation code to mark the end of the AArch64
7322   relocation enumerators that have direct mapping to ELF reloc codes.
7323   There are a few more enumerators after this one; those are mainly
7324   used by the AArch64 assembler for the internal fixup or to select
7325   one of the above enumerators.
7326 ENUM
7327   BFD_RELOC_AARCH64_GAS_INTERNAL_FIXUP
7328 ENUMDOC
7329   AArch64 pseudo relocation code to be used internally by the AArch64
7330   assembler and not (currently) written to any object files.
7331 ENUM
7332   BFD_RELOC_AARCH64_LDST_LO12
7333 ENUMDOC
7334   AArch64 unspecified load/store instruction, holding bits 0 to 11 of the
7335   address.  Used in conjunction with BFD_RELOC_AARCH64_ADR_HI21_PCREL.
7336 ENUM
7337   BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12
7338 ENUMDOC
7339   AArch64 pseudo relocation code for TLS local dynamic mode.  It's to be
7340   used internally by the AArch64 assembler and not (currently) written to
7341   any object files.
7342 ENUM
7343   BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12_NC
7344 ENUMDOC
7345   Similar as BFD_RELOC_AARCH64_TLSLD_LDST_DTPREL_LO12, but no overflow check.
7346 ENUM
7347   BFD_RELOC_AARCH64_TLSLE_LDST_TPREL_LO12
7348 ENUMDOC
7349   AArch64 pseudo relocation code for TLS local exec mode.  It's to be
7350   used internally by the AArch64 assembler and not (currently) written to
7351   any object files.
7352 ENUM
7353   BFD_RELOC_AARCH64_TLSLE_LDST_TPREL_LO12_NC
7354 ENUMDOC
7355   Similar as BFD_RELOC_AARCH64_TLSLE_LDST_TPREL_LO12, but no overflow check.
7356 ENUM
7357   BFD_RELOC_AARCH64_LD_GOT_LO12_NC
7358 ENUMDOC
7359   AArch64 pseudo relocation code to be used internally by the AArch64
7360   assembler and not (currently) written to any object files.
7361 ENUM
7362   BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_LO12_NC
7363 ENUMDOC
7364   AArch64 pseudo relocation code to be used internally by the AArch64
7365   assembler and not (currently) written to any object files.
7366 ENUM
7367   BFD_RELOC_AARCH64_TLSDESC_LD_LO12_NC
7368 ENUMDOC
7369   AArch64 pseudo relocation code to be used internally by the AArch64
7370   assembler and not (currently) written to any object files.
7371 ENUM
7372   BFD_RELOC_TILEPRO_COPY
7373 ENUMX
7374   BFD_RELOC_TILEPRO_GLOB_DAT
7375 ENUMX
7376   BFD_RELOC_TILEPRO_JMP_SLOT
7377 ENUMX
7378   BFD_RELOC_TILEPRO_RELATIVE
7379 ENUMX
7380   BFD_RELOC_TILEPRO_BROFF_X1
7381 ENUMX
7382   BFD_RELOC_TILEPRO_JOFFLONG_X1
7383 ENUMX
7384   BFD_RELOC_TILEPRO_JOFFLONG_X1_PLT
7385 ENUMX
7386   BFD_RELOC_TILEPRO_IMM8_X0
7387 ENUMX
7388   BFD_RELOC_TILEPRO_IMM8_Y0
7389 ENUMX
7390   BFD_RELOC_TILEPRO_IMM8_X1
7391 ENUMX
7392   BFD_RELOC_TILEPRO_IMM8_Y1
7393 ENUMX
7394   BFD_RELOC_TILEPRO_DEST_IMM8_X1
7395 ENUMX
7396   BFD_RELOC_TILEPRO_MT_IMM15_X1
7397 ENUMX
7398   BFD_RELOC_TILEPRO_MF_IMM15_X1
7399 ENUMX
7400   BFD_RELOC_TILEPRO_IMM16_X0
7401 ENUMX
7402   BFD_RELOC_TILEPRO_IMM16_X1
7403 ENUMX
7404   BFD_RELOC_TILEPRO_IMM16_X0_LO
7405 ENUMX
7406   BFD_RELOC_TILEPRO_IMM16_X1_LO
7407 ENUMX
7408   BFD_RELOC_TILEPRO_IMM16_X0_HI
7409 ENUMX
7410   BFD_RELOC_TILEPRO_IMM16_X1_HI
7411 ENUMX
7412   BFD_RELOC_TILEPRO_IMM16_X0_HA
7413 ENUMX
7414   BFD_RELOC_TILEPRO_IMM16_X1_HA
7415 ENUMX
7416   BFD_RELOC_TILEPRO_IMM16_X0_PCREL
7417 ENUMX
7418   BFD_RELOC_TILEPRO_IMM16_X1_PCREL
7419 ENUMX
7420   BFD_RELOC_TILEPRO_IMM16_X0_LO_PCREL
7421 ENUMX
7422   BFD_RELOC_TILEPRO_IMM16_X1_LO_PCREL
7423 ENUMX
7424   BFD_RELOC_TILEPRO_IMM16_X0_HI_PCREL
7425 ENUMX
7426   BFD_RELOC_TILEPRO_IMM16_X1_HI_PCREL
7427 ENUMX
7428   BFD_RELOC_TILEPRO_IMM16_X0_HA_PCREL
7429 ENUMX
7430   BFD_RELOC_TILEPRO_IMM16_X1_HA_PCREL
7431 ENUMX
7432   BFD_RELOC_TILEPRO_IMM16_X0_GOT
7433 ENUMX
7434   BFD_RELOC_TILEPRO_IMM16_X1_GOT
7435 ENUMX
7436   BFD_RELOC_TILEPRO_IMM16_X0_GOT_LO
7437 ENUMX
7438   BFD_RELOC_TILEPRO_IMM16_X1_GOT_LO
7439 ENUMX
7440   BFD_RELOC_TILEPRO_IMM16_X0_GOT_HI
7441 ENUMX
7442   BFD_RELOC_TILEPRO_IMM16_X1_GOT_HI
7443 ENUMX
7444   BFD_RELOC_TILEPRO_IMM16_X0_GOT_HA
7445 ENUMX
7446   BFD_RELOC_TILEPRO_IMM16_X1_GOT_HA
7447 ENUMX
7448   BFD_RELOC_TILEPRO_MMSTART_X0
7449 ENUMX
7450   BFD_RELOC_TILEPRO_MMEND_X0
7451 ENUMX
7452   BFD_RELOC_TILEPRO_MMSTART_X1
7453 ENUMX
7454   BFD_RELOC_TILEPRO_MMEND_X1
7455 ENUMX
7456   BFD_RELOC_TILEPRO_SHAMT_X0
7457 ENUMX
7458   BFD_RELOC_TILEPRO_SHAMT_X1
7459 ENUMX
7460   BFD_RELOC_TILEPRO_SHAMT_Y0
7461 ENUMX
7462   BFD_RELOC_TILEPRO_SHAMT_Y1
7463 ENUMX
7464   BFD_RELOC_TILEPRO_TLS_GD_CALL
7465 ENUMX
7466   BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD
7467 ENUMX
7468   BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD
7469 ENUMX
7470   BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD
7471 ENUMX
7472   BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD
7473 ENUMX
7474   BFD_RELOC_TILEPRO_TLS_IE_LOAD
7475 ENUMX
7476   BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD
7477 ENUMX
7478   BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD
7479 ENUMX
7480   BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO
7481 ENUMX
7482   BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_LO
7483 ENUMX
7484   BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HI
7485 ENUMX
7486   BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HI
7487 ENUMX
7488   BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HA
7489 ENUMX
7490   BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HA
7491 ENUMX
7492   BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE
7493 ENUMX
7494   BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE
7495 ENUMX
7496   BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_LO
7497 ENUMX
7498   BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_LO
7499 ENUMX
7500   BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HI
7501 ENUMX
7502   BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HI
7503 ENUMX
7504   BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HA
7505 ENUMX
7506   BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HA
7507 ENUMX
7508   BFD_RELOC_TILEPRO_TLS_DTPMOD32
7509 ENUMX
7510   BFD_RELOC_TILEPRO_TLS_DTPOFF32
7511 ENUMX
7512   BFD_RELOC_TILEPRO_TLS_TPOFF32
7513 ENUMX
7514   BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE
7515 ENUMX
7516   BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE
7517 ENUMX
7518   BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_LO
7519 ENUMX
7520   BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_LO
7521 ENUMX
7522   BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HI
7523 ENUMX
7524   BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HI
7525 ENUMX
7526   BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HA
7527 ENUMX
7528   BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HA
7529 ENUMDOC
7530   Tilera TILEPro Relocations.
7531 ENUM
7532   BFD_RELOC_TILEGX_HW0
7533 ENUMX
7534   BFD_RELOC_TILEGX_HW1
7535 ENUMX
7536   BFD_RELOC_TILEGX_HW2
7537 ENUMX
7538   BFD_RELOC_TILEGX_HW3
7539 ENUMX
7540   BFD_RELOC_TILEGX_HW0_LAST
7541 ENUMX
7542   BFD_RELOC_TILEGX_HW1_LAST
7543 ENUMX
7544   BFD_RELOC_TILEGX_HW2_LAST
7545 ENUMX
7546   BFD_RELOC_TILEGX_COPY
7547 ENUMX
7548   BFD_RELOC_TILEGX_GLOB_DAT
7549 ENUMX
7550   BFD_RELOC_TILEGX_JMP_SLOT
7551 ENUMX
7552   BFD_RELOC_TILEGX_RELATIVE
7553 ENUMX
7554   BFD_RELOC_TILEGX_BROFF_X1
7555 ENUMX
7556   BFD_RELOC_TILEGX_JUMPOFF_X1
7557 ENUMX
7558   BFD_RELOC_TILEGX_JUMPOFF_X1_PLT
7559 ENUMX
7560   BFD_RELOC_TILEGX_IMM8_X0
7561 ENUMX
7562   BFD_RELOC_TILEGX_IMM8_Y0
7563 ENUMX
7564   BFD_RELOC_TILEGX_IMM8_X1
7565 ENUMX
7566   BFD_RELOC_TILEGX_IMM8_Y1
7567 ENUMX
7568   BFD_RELOC_TILEGX_DEST_IMM8_X1
7569 ENUMX
7570   BFD_RELOC_TILEGX_MT_IMM14_X1
7571 ENUMX
7572   BFD_RELOC_TILEGX_MF_IMM14_X1
7573 ENUMX
7574   BFD_RELOC_TILEGX_MMSTART_X0
7575 ENUMX
7576   BFD_RELOC_TILEGX_MMEND_X0
7577 ENUMX
7578   BFD_RELOC_TILEGX_SHAMT_X0
7579 ENUMX
7580   BFD_RELOC_TILEGX_SHAMT_X1
7581 ENUMX
7582   BFD_RELOC_TILEGX_SHAMT_Y0
7583 ENUMX
7584   BFD_RELOC_TILEGX_SHAMT_Y1
7585 ENUMX
7586   BFD_RELOC_TILEGX_IMM16_X0_HW0
7587 ENUMX
7588   BFD_RELOC_TILEGX_IMM16_X1_HW0
7589 ENUMX
7590   BFD_RELOC_TILEGX_IMM16_X0_HW1
7591 ENUMX
7592   BFD_RELOC_TILEGX_IMM16_X1_HW1
7593 ENUMX
7594   BFD_RELOC_TILEGX_IMM16_X0_HW2
7595 ENUMX
7596   BFD_RELOC_TILEGX_IMM16_X1_HW2
7597 ENUMX
7598   BFD_RELOC_TILEGX_IMM16_X0_HW3
7599 ENUMX
7600   BFD_RELOC_TILEGX_IMM16_X1_HW3
7601 ENUMX
7602   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST
7603 ENUMX
7604   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST
7605 ENUMX
7606   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST
7607 ENUMX
7608   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST
7609 ENUMX
7610   BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST
7611 ENUMX
7612   BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST
7613 ENUMX
7614   BFD_RELOC_TILEGX_IMM16_X0_HW0_PCREL
7615 ENUMX
7616   BFD_RELOC_TILEGX_IMM16_X1_HW0_PCREL
7617 ENUMX
7618   BFD_RELOC_TILEGX_IMM16_X0_HW1_PCREL
7619 ENUMX
7620   BFD_RELOC_TILEGX_IMM16_X1_HW1_PCREL
7621 ENUMX
7622   BFD_RELOC_TILEGX_IMM16_X0_HW2_PCREL
7623 ENUMX
7624   BFD_RELOC_TILEGX_IMM16_X1_HW2_PCREL
7625 ENUMX
7626   BFD_RELOC_TILEGX_IMM16_X0_HW3_PCREL
7627 ENUMX
7628   BFD_RELOC_TILEGX_IMM16_X1_HW3_PCREL
7629 ENUMX
7630   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PCREL
7631 ENUMX
7632   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PCREL
7633 ENUMX
7634   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PCREL
7635 ENUMX
7636   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PCREL
7637 ENUMX
7638   BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PCREL
7639 ENUMX
7640   BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PCREL
7641 ENUMX
7642   BFD_RELOC_TILEGX_IMM16_X0_HW0_GOT
7643 ENUMX
7644   BFD_RELOC_TILEGX_IMM16_X1_HW0_GOT
7645 ENUMX
7646   BFD_RELOC_TILEGX_IMM16_X0_HW0_PLT_PCREL
7647 ENUMX
7648   BFD_RELOC_TILEGX_IMM16_X1_HW0_PLT_PCREL
7649 ENUMX
7650   BFD_RELOC_TILEGX_IMM16_X0_HW1_PLT_PCREL
7651 ENUMX
7652   BFD_RELOC_TILEGX_IMM16_X1_HW1_PLT_PCREL
7653 ENUMX
7654   BFD_RELOC_TILEGX_IMM16_X0_HW2_PLT_PCREL
7655 ENUMX
7656   BFD_RELOC_TILEGX_IMM16_X1_HW2_PLT_PCREL
7657 ENUMX
7658   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_GOT
7659 ENUMX
7660   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_GOT
7661 ENUMX
7662   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_GOT
7663 ENUMX
7664   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_GOT
7665 ENUMX
7666   BFD_RELOC_TILEGX_IMM16_X0_HW3_PLT_PCREL
7667 ENUMX
7668   BFD_RELOC_TILEGX_IMM16_X1_HW3_PLT_PCREL
7669 ENUMX
7670   BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_GD
7671 ENUMX
7672   BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_GD
7673 ENUMX
7674   BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_LE
7675 ENUMX
7676   BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_LE
7677 ENUMX
7678   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_LE
7679 ENUMX
7680   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_LE
7681 ENUMX
7682   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_LE
7683 ENUMX
7684   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_LE
7685 ENUMX
7686   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_GD
7687 ENUMX
7688   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_GD
7689 ENUMX
7690   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_GD
7691 ENUMX
7692   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_GD
7693 ENUMX
7694   BFD_RELOC_TILEGX_IMM16_X0_HW0_TLS_IE
7695 ENUMX
7696   BFD_RELOC_TILEGX_IMM16_X1_HW0_TLS_IE
7697 ENUMX
7698   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL
7699 ENUMX
7700   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL
7701 ENUMX
7702   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL
7703 ENUMX
7704   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL
7705 ENUMX
7706   BFD_RELOC_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL
7707 ENUMX
7708   BFD_RELOC_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL
7709 ENUMX
7710   BFD_RELOC_TILEGX_IMM16_X0_HW0_LAST_TLS_IE
7711 ENUMX
7712   BFD_RELOC_TILEGX_IMM16_X1_HW0_LAST_TLS_IE
7713 ENUMX
7714   BFD_RELOC_TILEGX_IMM16_X0_HW1_LAST_TLS_IE
7715 ENUMX
7716   BFD_RELOC_TILEGX_IMM16_X1_HW1_LAST_TLS_IE
7717 ENUMX
7718   BFD_RELOC_TILEGX_TLS_DTPMOD64
7719 ENUMX
7720   BFD_RELOC_TILEGX_TLS_DTPOFF64
7721 ENUMX
7722   BFD_RELOC_TILEGX_TLS_TPOFF64
7723 ENUMX
7724   BFD_RELOC_TILEGX_TLS_DTPMOD32
7725 ENUMX
7726   BFD_RELOC_TILEGX_TLS_DTPOFF32
7727 ENUMX
7728   BFD_RELOC_TILEGX_TLS_TPOFF32
7729 ENUMX
7730   BFD_RELOC_TILEGX_TLS_GD_CALL
7731 ENUMX
7732   BFD_RELOC_TILEGX_IMM8_X0_TLS_GD_ADD
7733 ENUMX
7734   BFD_RELOC_TILEGX_IMM8_X1_TLS_GD_ADD
7735 ENUMX
7736   BFD_RELOC_TILEGX_IMM8_Y0_TLS_GD_ADD
7737 ENUMX
7738   BFD_RELOC_TILEGX_IMM8_Y1_TLS_GD_ADD
7739 ENUMX
7740   BFD_RELOC_TILEGX_TLS_IE_LOAD
7741 ENUMX
7742   BFD_RELOC_TILEGX_IMM8_X0_TLS_ADD
7743 ENUMX
7744   BFD_RELOC_TILEGX_IMM8_X1_TLS_ADD
7745 ENUMX
7746   BFD_RELOC_TILEGX_IMM8_Y0_TLS_ADD
7747 ENUMX
7748   BFD_RELOC_TILEGX_IMM8_Y1_TLS_ADD
7749 ENUMDOC
7750   Tilera TILE-Gx Relocations.
7751
7752 ENUM
7753   BFD_RELOC_BPF_64
7754 ENUMX
7755   BFD_RELOC_BPF_DISP32
7756 ENUMX
7757   BFD_RELOC_BPF_DISP16
7758 ENUMDOC
7759   Linux eBPF relocations.
7760
7761 ENUM
7762   BFD_RELOC_EPIPHANY_SIMM8
7763 ENUMDOC
7764   Adapteva EPIPHANY - 8 bit signed pc-relative displacement
7765 ENUM
7766   BFD_RELOC_EPIPHANY_SIMM24
7767 ENUMDOC
7768   Adapteva EPIPHANY - 24 bit signed pc-relative displacement
7769 ENUM
7770   BFD_RELOC_EPIPHANY_HIGH
7771 ENUMDOC
7772   Adapteva EPIPHANY - 16 most-significant bits of absolute address
7773 ENUM
7774   BFD_RELOC_EPIPHANY_LOW
7775 ENUMDOC
7776   Adapteva EPIPHANY - 16 least-significant bits of absolute address
7777 ENUM
7778   BFD_RELOC_EPIPHANY_SIMM11
7779 ENUMDOC
7780   Adapteva EPIPHANY - 11 bit signed number - add/sub immediate
7781 ENUM
7782   BFD_RELOC_EPIPHANY_IMM11
7783 ENUMDOC
7784   Adapteva EPIPHANY - 11 bit sign-magnitude number (ld/st displacement)
7785 ENUM
7786   BFD_RELOC_EPIPHANY_IMM8
7787 ENUMDOC
7788   Adapteva EPIPHANY - 8 bit immediate for 16 bit mov instruction.
7789
7790 ENUM
7791   BFD_RELOC_VISIUM_HI16
7792 ENUMX
7793   BFD_RELOC_VISIUM_LO16
7794 ENUMX
7795   BFD_RELOC_VISIUM_IM16
7796 ENUMX
7797   BFD_RELOC_VISIUM_REL16
7798 ENUMX
7799   BFD_RELOC_VISIUM_HI16_PCREL
7800 ENUMX
7801   BFD_RELOC_VISIUM_LO16_PCREL
7802 ENUMX
7803   BFD_RELOC_VISIUM_IM16_PCREL
7804 ENUMDOC
7805   Visium Relocations.
7806
7807 ENUM
7808   BFD_RELOC_WASM32_LEB128
7809 ENUMX
7810   BFD_RELOC_WASM32_LEB128_GOT
7811 ENUMX
7812   BFD_RELOC_WASM32_LEB128_GOT_CODE
7813 ENUMX
7814   BFD_RELOC_WASM32_LEB128_PLT
7815 ENUMX
7816   BFD_RELOC_WASM32_PLT_INDEX
7817 ENUMX
7818   BFD_RELOC_WASM32_ABS32_CODE
7819 ENUMX
7820   BFD_RELOC_WASM32_COPY
7821 ENUMX
7822   BFD_RELOC_WASM32_CODE_POINTER
7823 ENUMX
7824   BFD_RELOC_WASM32_INDEX
7825 ENUMX
7826   BFD_RELOC_WASM32_PLT_SIG
7827 ENUMDOC
7828   WebAssembly relocations.
7829
7830 ENUM
7831   BFD_RELOC_CKCORE_NONE
7832 ENUMX
7833   BFD_RELOC_CKCORE_ADDR32
7834 ENUMX
7835   BFD_RELOC_CKCORE_PCREL_IMM8BY4
7836 ENUMX
7837   BFD_RELOC_CKCORE_PCREL_IMM11BY2
7838 ENUMX
7839   BFD_RELOC_CKCORE_PCREL_IMM4BY2
7840 ENUMX
7841   BFD_RELOC_CKCORE_PCREL32
7842 ENUMX
7843   BFD_RELOC_CKCORE_PCREL_JSR_IMM11BY2
7844 ENUMX
7845   BFD_RELOC_CKCORE_GNU_VTINHERIT
7846 ENUMX
7847   BFD_RELOC_CKCORE_GNU_VTENTRY
7848 ENUMX
7849   BFD_RELOC_CKCORE_RELATIVE
7850 ENUMX
7851   BFD_RELOC_CKCORE_COPY
7852 ENUMX
7853   BFD_RELOC_CKCORE_GLOB_DAT
7854 ENUMX
7855   BFD_RELOC_CKCORE_JUMP_SLOT
7856 ENUMX
7857   BFD_RELOC_CKCORE_GOTOFF
7858 ENUMX
7859   BFD_RELOC_CKCORE_GOTPC
7860 ENUMX
7861   BFD_RELOC_CKCORE_GOT32
7862 ENUMX
7863   BFD_RELOC_CKCORE_PLT32
7864 ENUMX
7865   BFD_RELOC_CKCORE_ADDRGOT
7866 ENUMX
7867   BFD_RELOC_CKCORE_ADDRPLT
7868 ENUMX
7869   BFD_RELOC_CKCORE_PCREL_IMM26BY2
7870 ENUMX
7871   BFD_RELOC_CKCORE_PCREL_IMM16BY2
7872 ENUMX
7873   BFD_RELOC_CKCORE_PCREL_IMM16BY4
7874 ENUMX
7875   BFD_RELOC_CKCORE_PCREL_IMM10BY2
7876 ENUMX
7877   BFD_RELOC_CKCORE_PCREL_IMM10BY4
7878 ENUMX
7879   BFD_RELOC_CKCORE_ADDR_HI16
7880 ENUMX
7881   BFD_RELOC_CKCORE_ADDR_LO16
7882 ENUMX
7883   BFD_RELOC_CKCORE_GOTPC_HI16
7884 ENUMX
7885   BFD_RELOC_CKCORE_GOTPC_LO16
7886 ENUMX
7887   BFD_RELOC_CKCORE_GOTOFF_HI16
7888 ENUMX
7889   BFD_RELOC_CKCORE_GOTOFF_LO16
7890 ENUMX
7891   BFD_RELOC_CKCORE_GOT12
7892 ENUMX
7893   BFD_RELOC_CKCORE_GOT_HI16
7894 ENUMX
7895   BFD_RELOC_CKCORE_GOT_LO16
7896 ENUMX
7897   BFD_RELOC_CKCORE_PLT12
7898 ENUMX
7899   BFD_RELOC_CKCORE_PLT_HI16
7900 ENUMX
7901   BFD_RELOC_CKCORE_PLT_LO16
7902 ENUMX
7903   BFD_RELOC_CKCORE_ADDRGOT_HI16
7904 ENUMX
7905   BFD_RELOC_CKCORE_ADDRGOT_LO16
7906 ENUMX
7907   BFD_RELOC_CKCORE_ADDRPLT_HI16
7908 ENUMX
7909   BFD_RELOC_CKCORE_ADDRPLT_LO16
7910 ENUMX
7911   BFD_RELOC_CKCORE_PCREL_JSR_IMM26BY2
7912 ENUMX
7913   BFD_RELOC_CKCORE_TOFFSET_LO16
7914 ENUMX
7915   BFD_RELOC_CKCORE_DOFFSET_LO16
7916 ENUMX
7917   BFD_RELOC_CKCORE_PCREL_IMM18BY2
7918 ENUMX
7919   BFD_RELOC_CKCORE_DOFFSET_IMM18
7920 ENUMX
7921   BFD_RELOC_CKCORE_DOFFSET_IMM18BY2
7922 ENUMX
7923   BFD_RELOC_CKCORE_DOFFSET_IMM18BY4
7924 ENUMX
7925   BFD_RELOC_CKCORE_GOTOFF_IMM18
7926 ENUMX
7927   BFD_RELOC_CKCORE_GOT_IMM18BY4
7928 ENUMX
7929   BFD_RELOC_CKCORE_PLT_IMM18BY4
7930 ENUMX
7931   BFD_RELOC_CKCORE_PCREL_IMM7BY4
7932 ENUMX
7933   BFD_RELOC_CKCORE_TLS_LE32
7934 ENUMX
7935   BFD_RELOC_CKCORE_TLS_IE32
7936 ENUMX
7937   BFD_RELOC_CKCORE_TLS_GD32
7938 ENUMX
7939   BFD_RELOC_CKCORE_TLS_LDM32
7940 ENUMX
7941   BFD_RELOC_CKCORE_TLS_LDO32
7942 ENUMX
7943   BFD_RELOC_CKCORE_TLS_DTPMOD32
7944 ENUMX
7945   BFD_RELOC_CKCORE_TLS_DTPOFF32
7946 ENUMX
7947   BFD_RELOC_CKCORE_TLS_TPOFF32
7948 ENUMX
7949   BFD_RELOC_CKCORE_PCREL_FLRW_IMM8BY4
7950 ENUMX
7951   BFD_RELOC_CKCORE_NOJSRI
7952 ENUMX
7953   BFD_RELOC_CKCORE_CALLGRAPH
7954 ENUMX
7955   BFD_RELOC_CKCORE_IRELATIVE
7956 ENUMX
7957   BFD_RELOC_CKCORE_PCREL_BLOOP_IMM4BY4
7958 ENUMX
7959   BFD_RELOC_CKCORE_PCREL_BLOOP_IMM12BY4
7960 ENUMDOC
7961   C-SKY relocations.
7962
7963 ENUM
7964   BFD_RELOC_S12Z_OPR
7965 ENUMDOC
7966   S12Z relocations.
7967
7968 ENUM
7969   BFD_RELOC_LARCH_TLS_DTPMOD32
7970 ENUMX
7971   BFD_RELOC_LARCH_TLS_DTPREL32
7972 ENUMX
7973   BFD_RELOC_LARCH_TLS_DTPMOD64
7974 ENUMX
7975   BFD_RELOC_LARCH_TLS_DTPREL64
7976 ENUMX
7977   BFD_RELOC_LARCH_TLS_TPREL32
7978 ENUMX
7979   BFD_RELOC_LARCH_TLS_TPREL64
7980 ENUMX
7981   BFD_RELOC_LARCH_MARK_LA
7982 ENUMX
7983   BFD_RELOC_LARCH_MARK_PCREL
7984 ENUMX
7985   BFD_RELOC_LARCH_SOP_PUSH_PCREL
7986 ENUMX
7987   BFD_RELOC_LARCH_SOP_PUSH_ABSOLUTE
7988 ENUMX
7989   BFD_RELOC_LARCH_SOP_PUSH_DUP
7990 ENUMX
7991   BFD_RELOC_LARCH_SOP_PUSH_GPREL
7992 ENUMX
7993   BFD_RELOC_LARCH_SOP_PUSH_TLS_TPREL
7994 ENUMX
7995   BFD_RELOC_LARCH_SOP_PUSH_TLS_GOT
7996 ENUMX
7997   BFD_RELOC_LARCH_SOP_PUSH_TLS_GD
7998 ENUMX
7999   BFD_RELOC_LARCH_SOP_PUSH_PLT_PCREL
8000 ENUMX
8001   BFD_RELOC_LARCH_SOP_ASSERT
8002 ENUMX
8003   BFD_RELOC_LARCH_SOP_NOT
8004 ENUMX
8005   BFD_RELOC_LARCH_SOP_SUB
8006 ENUMX
8007   BFD_RELOC_LARCH_SOP_SL
8008 ENUMX
8009   BFD_RELOC_LARCH_SOP_SR
8010 ENUMX
8011   BFD_RELOC_LARCH_SOP_ADD
8012 ENUMX
8013   BFD_RELOC_LARCH_SOP_AND
8014 ENUMX
8015   BFD_RELOC_LARCH_SOP_IF_ELSE
8016 ENUMX
8017   BFD_RELOC_LARCH_SOP_POP_32_S_10_5
8018 ENUMX
8019   BFD_RELOC_LARCH_SOP_POP_32_U_10_12
8020 ENUMX
8021   BFD_RELOC_LARCH_SOP_POP_32_S_10_12
8022 ENUMX
8023   BFD_RELOC_LARCH_SOP_POP_32_S_10_16
8024 ENUMX
8025   BFD_RELOC_LARCH_SOP_POP_32_S_10_16_S2
8026 ENUMX
8027   BFD_RELOC_LARCH_SOP_POP_32_S_5_20
8028 ENUMX
8029   BFD_RELOC_LARCH_SOP_POP_32_S_0_5_10_16_S2
8030 ENUMX
8031   BFD_RELOC_LARCH_SOP_POP_32_S_0_10_10_16_S2
8032 ENUMX
8033   BFD_RELOC_LARCH_SOP_POP_32_U
8034 ENUMX
8035   BFD_RELOC_LARCH_ADD8
8036 ENUMX
8037   BFD_RELOC_LARCH_ADD16
8038 ENUMX
8039   BFD_RELOC_LARCH_ADD24
8040 ENUMX
8041   BFD_RELOC_LARCH_ADD32
8042 ENUMX
8043   BFD_RELOC_LARCH_ADD64
8044 ENUMX
8045   BFD_RELOC_LARCH_SUB8
8046 ENUMX
8047   BFD_RELOC_LARCH_SUB16
8048 ENUMX
8049   BFD_RELOC_LARCH_SUB24
8050 ENUMX
8051   BFD_RELOC_LARCH_SUB32
8052 ENUMX
8053   BFD_RELOC_LARCH_SUB64
8054
8055 ENUMX
8056   BFD_RELOC_LARCH_B16
8057 ENUMX
8058   BFD_RELOC_LARCH_B21
8059 ENUMX
8060   BFD_RELOC_LARCH_B26
8061
8062 ENUMX
8063   BFD_RELOC_LARCH_ABS_HI20
8064 ENUMX
8065   BFD_RELOC_LARCH_ABS_LO12
8066 ENUMX
8067   BFD_RELOC_LARCH_ABS64_LO20
8068 ENUMX
8069   BFD_RELOC_LARCH_ABS64_HI12
8070
8071 ENUMX
8072   BFD_RELOC_LARCH_PCALA_HI20
8073 ENUMX
8074   BFD_RELOC_LARCH_PCALA_LO12
8075 ENUMX
8076   BFD_RELOC_LARCH_PCALA64_LO20
8077 ENUMX
8078   BFD_RELOC_LARCH_PCALA64_HI12
8079
8080 ENUMX
8081   BFD_RELOC_LARCH_GOT_PC_HI20
8082 ENUMX
8083   BFD_RELOC_LARCH_GOT_PC_LO12
8084 ENUMX
8085   BFD_RELOC_LARCH_GOT64_PC_LO20
8086 ENUMX
8087   BFD_RELOC_LARCH_GOT64_PC_HI12
8088 ENUMX
8089   BFD_RELOC_LARCH_GOT_HI20
8090 ENUMX
8091   BFD_RELOC_LARCH_GOT_LO12
8092 ENUMX
8093   BFD_RELOC_LARCH_GOT64_LO20
8094 ENUMX
8095   BFD_RELOC_LARCH_GOT64_HI12
8096
8097 ENUMX
8098   BFD_RELOC_LARCH_TLS_LE_HI20
8099 ENUMX
8100   BFD_RELOC_LARCH_TLS_LE_LO12
8101 ENUMX
8102   BFD_RELOC_LARCH_TLS_LE64_LO20
8103 ENUMX
8104   BFD_RELOC_LARCH_TLS_LE64_HI12
8105 ENUMX
8106   BFD_RELOC_LARCH_TLS_IE_PC_HI20
8107 ENUMX
8108   BFD_RELOC_LARCH_TLS_IE_PC_LO12
8109 ENUMX
8110   BFD_RELOC_LARCH_TLS_IE64_PC_LO20
8111 ENUMX
8112   BFD_RELOC_LARCH_TLS_IE64_PC_HI12
8113 ENUMX
8114   BFD_RELOC_LARCH_TLS_IE_HI20
8115 ENUMX
8116   BFD_RELOC_LARCH_TLS_IE_LO12
8117 ENUMX
8118   BFD_RELOC_LARCH_TLS_IE64_LO20
8119 ENUMX
8120   BFD_RELOC_LARCH_TLS_IE64_HI12
8121 ENUMX
8122   BFD_RELOC_LARCH_TLS_LD_PC_HI20
8123 ENUMX
8124   BFD_RELOC_LARCH_TLS_LD_HI20
8125 ENUMX
8126   BFD_RELOC_LARCH_TLS_GD_PC_HI20
8127 ENUMX
8128   BFD_RELOC_LARCH_TLS_GD_HI20
8129
8130 ENUMX
8131   BFD_RELOC_LARCH_32_PCREL
8132
8133 ENUMX
8134   BFD_RELOC_LARCH_RELAX
8135
8136 ENUMX
8137   BFD_RELOC_LARCH_DELETE
8138
8139 ENUMX
8140   BFD_RELOC_LARCH_ALIGN
8141
8142 ENUMX
8143   BFD_RELOC_LARCH_PCREL20_S2
8144
8145 ENUMX
8146   BFD_RELOC_LARCH_CFA
8147
8148 ENUMX
8149   BFD_RELOC_LARCH_ADD6
8150 ENUMX
8151   BFD_RELOC_LARCH_SUB6
8152
8153 ENUMX
8154   BFD_RELOC_LARCH_ADD_ULEB128
8155 ENUMX
8156   BFD_RELOC_LARCH_SUB_ULEB128
8157
8158 ENUMX
8159   BFD_RELOC_LARCH_64_PCREL
8160
8161 ENUMDOC
8162   LARCH relocations.
8163
8164 ENDSENUM
8165   BFD_RELOC_UNUSED
8166
8167 CODE_FRAGMENT
8168 .typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
8169 .
8170 */
8171
8172 /*
8173 FUNCTION
8174         bfd_reloc_type_lookup
8175         bfd_reloc_name_lookup
8176
8177 SYNOPSIS
8178         reloc_howto_type *bfd_reloc_type_lookup
8179           (bfd *abfd, bfd_reloc_code_real_type code);
8180         reloc_howto_type *bfd_reloc_name_lookup
8181           (bfd *abfd, const char *reloc_name);
8182
8183 DESCRIPTION
8184         Return a pointer to a howto structure which, when
8185         invoked, will perform the relocation @var{code} on data from the
8186         architecture noted.
8187 */
8188
8189 reloc_howto_type *
8190 bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
8191 {
8192   return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
8193 }
8194
8195 reloc_howto_type *
8196 bfd_reloc_name_lookup (bfd *abfd, const char *reloc_name)
8197 {
8198   return BFD_SEND (abfd, reloc_name_lookup, (abfd, reloc_name));
8199 }
8200
8201 static reloc_howto_type bfd_howto_32 =
8202 HOWTO (0, 00, 4, 32, false, 0, complain_overflow_dont, 0, "VRT32", false, 0xffffffff, 0xffffffff, true);
8203
8204 /*
8205 INTERNAL_FUNCTION
8206         bfd_default_reloc_type_lookup
8207
8208 SYNOPSIS
8209         reloc_howto_type *bfd_default_reloc_type_lookup
8210           (bfd *abfd, bfd_reloc_code_real_type  code);
8211
8212 DESCRIPTION
8213         Provides a default relocation lookup routine for any architecture.
8214 */
8215
8216 reloc_howto_type *
8217 bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
8218 {
8219   /* Very limited support is provided for relocs in generic targets
8220      such as elf32-little.  FIXME: Should we always return NULL?  */
8221   if (code == BFD_RELOC_CTOR
8222       && bfd_arch_bits_per_address (abfd) == 32)
8223     return &bfd_howto_32;
8224   return NULL;
8225 }
8226
8227 /*
8228 FUNCTION
8229         bfd_get_reloc_code_name
8230
8231 SYNOPSIS
8232         const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
8233
8234 DESCRIPTION
8235         Provides a printable name for the supplied relocation code.
8236         Useful mainly for printing error messages.
8237 */
8238
8239 const char *
8240 bfd_get_reloc_code_name (bfd_reloc_code_real_type code)
8241 {
8242   if (code > BFD_RELOC_UNUSED)
8243     return 0;
8244   return bfd_reloc_code_real_names[code];
8245 }
8246
8247 /*
8248 INTERNAL_FUNCTION
8249         bfd_generic_relax_section
8250
8251 SYNOPSIS
8252         bool bfd_generic_relax_section
8253           (bfd *abfd,
8254            asection *section,
8255            struct bfd_link_info *,
8256            bool *);
8257
8258 DESCRIPTION
8259         Provides default handling for relaxing for back ends which
8260         don't do relaxing.
8261 */
8262
8263 bool
8264 bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
8265                            asection *section ATTRIBUTE_UNUSED,
8266                            struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
8267                            bool *again)
8268 {
8269   if (bfd_link_relocatable (link_info))
8270     (*link_info->callbacks->einfo)
8271       (_("%P%F: --relax and -r may not be used together\n"));
8272
8273   *again = false;
8274   return true;
8275 }
8276
8277 /*
8278 INTERNAL_FUNCTION
8279         bfd_generic_gc_sections
8280
8281 SYNOPSIS
8282         bool bfd_generic_gc_sections
8283           (bfd *, struct bfd_link_info *);
8284
8285 DESCRIPTION
8286         Provides default handling for relaxing for back ends which
8287         don't do section gc -- i.e., does nothing.
8288 */
8289
8290 bool
8291 bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED,
8292                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
8293 {
8294   return true;
8295 }
8296
8297 /*
8298 INTERNAL_FUNCTION
8299         bfd_generic_lookup_section_flags
8300
8301 SYNOPSIS
8302         bool bfd_generic_lookup_section_flags
8303           (struct bfd_link_info *, struct flag_info *, asection *);
8304
8305 DESCRIPTION
8306         Provides default handling for section flags lookup
8307         -- i.e., does nothing.
8308         Returns FALSE if the section should be omitted, otherwise TRUE.
8309 */
8310
8311 bool
8312 bfd_generic_lookup_section_flags (struct bfd_link_info *info ATTRIBUTE_UNUSED,
8313                                   struct flag_info *flaginfo,
8314                                   asection *section ATTRIBUTE_UNUSED)
8315 {
8316   if (flaginfo != NULL)
8317     {
8318       _bfd_error_handler (_("INPUT_SECTION_FLAGS are not supported"));
8319       return false;
8320     }
8321   return true;
8322 }
8323
8324 /*
8325 INTERNAL_FUNCTION
8326         bfd_generic_merge_sections
8327
8328 SYNOPSIS
8329         bool bfd_generic_merge_sections
8330           (bfd *, struct bfd_link_info *);
8331
8332 DESCRIPTION
8333         Provides default handling for SEC_MERGE section merging for back ends
8334         which don't have SEC_MERGE support -- i.e., does nothing.
8335 */
8336
8337 bool
8338 bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED,
8339                             struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
8340 {
8341   return true;
8342 }
8343
8344 /*
8345 INTERNAL_FUNCTION
8346         bfd_generic_get_relocated_section_contents
8347
8348 SYNOPSIS
8349         bfd_byte *bfd_generic_get_relocated_section_contents
8350           (bfd *abfd,
8351            struct bfd_link_info *link_info,
8352            struct bfd_link_order *link_order,
8353            bfd_byte *data,
8354            bool relocatable,
8355            asymbol **symbols);
8356
8357 DESCRIPTION
8358         Provides default handling of relocation effort for back ends
8359         which can't be bothered to do it efficiently.
8360 */
8361
8362 bfd_byte *
8363 bfd_generic_get_relocated_section_contents (bfd *abfd,
8364                                             struct bfd_link_info *link_info,
8365                                             struct bfd_link_order *link_order,
8366                                             bfd_byte *data,
8367                                             bool relocatable,
8368                                             asymbol **symbols)
8369 {
8370   bfd *input_bfd = link_order->u.indirect.section->owner;
8371   asection *input_section = link_order->u.indirect.section;
8372   long reloc_size;
8373   arelent **reloc_vector;
8374   long reloc_count;
8375
8376   reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
8377   if (reloc_size < 0)
8378     return NULL;
8379
8380   /* Read in the section.  */
8381   bfd_byte *orig_data = data;
8382   if (!bfd_get_full_section_contents (input_bfd, input_section, &data))
8383     return NULL;
8384
8385   if (data == NULL)
8386     return NULL;
8387
8388   if (reloc_size == 0)
8389     return data;
8390
8391   reloc_vector = (arelent **) bfd_malloc (reloc_size);
8392   if (reloc_vector == NULL)
8393     goto error_return;
8394
8395   reloc_count = bfd_canonicalize_reloc (input_bfd,
8396                                         input_section,
8397                                         reloc_vector,
8398                                         symbols);
8399   if (reloc_count < 0)
8400     goto error_return;
8401
8402   if (reloc_count > 0)
8403     {
8404       arelent **parent;
8405
8406       for (parent = reloc_vector; *parent != NULL; parent++)
8407         {
8408           char *error_message = NULL;
8409           asymbol *symbol;
8410           bfd_reloc_status_type r;
8411
8412           symbol = *(*parent)->sym_ptr_ptr;
8413           /* PR ld/19628: A specially crafted input file
8414              can result in a NULL symbol pointer here.  */
8415           if (symbol == NULL)
8416             {
8417               link_info->callbacks->einfo
8418                 /* xgettext:c-format */
8419                 (_("%X%P: %pB(%pA): error: relocation for offset %V has no value\n"),
8420                  abfd, input_section, (* parent)->address);
8421               goto error_return;
8422             }
8423
8424           /* Zap reloc field when the symbol is from a discarded
8425              section, ignoring any addend.  Do the same when called
8426              from bfd_simple_get_relocated_section_contents for
8427              undefined symbols in debug sections.  This is to keep
8428              debug info reasonably sane, in particular so that
8429              DW_FORM_ref_addr to another file's .debug_info isn't
8430              confused with an offset into the current file's
8431              .debug_info.  */
8432           if ((symbol->section != NULL && discarded_section (symbol->section))
8433               || (symbol->section == bfd_und_section_ptr
8434                   && (input_section->flags & SEC_DEBUGGING) != 0
8435                   && link_info->input_bfds == link_info->output_bfd))
8436             {
8437               bfd_vma off;
8438               static reloc_howto_type none_howto
8439                 = HOWTO (0, 0, 0, 0, false, 0, complain_overflow_dont, NULL,
8440                          "unused", false, 0, 0, false);
8441
8442               off = ((*parent)->address
8443                      * bfd_octets_per_byte (input_bfd, input_section));
8444               _bfd_clear_contents ((*parent)->howto, input_bfd,
8445                                    input_section, data, off);
8446               (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
8447               (*parent)->addend = 0;
8448               (*parent)->howto = &none_howto;
8449               r = bfd_reloc_ok;
8450             }
8451           else
8452             r = bfd_perform_relocation (input_bfd,
8453                                         *parent,
8454                                         data,
8455                                         input_section,
8456                                         relocatable ? abfd : NULL,
8457                                         &error_message);
8458
8459           if (relocatable)
8460             {
8461               asection *os = input_section->output_section;
8462
8463               /* A partial link, so keep the relocs.  */
8464               os->orelocation[os->reloc_count] = *parent;
8465               os->reloc_count++;
8466             }
8467
8468           if (r != bfd_reloc_ok)
8469             {
8470               switch (r)
8471                 {
8472                 case bfd_reloc_undefined:
8473                   (*link_info->callbacks->undefined_symbol)
8474                     (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8475                      input_bfd, input_section, (*parent)->address, true);
8476                   break;
8477                 case bfd_reloc_dangerous:
8478                   BFD_ASSERT (error_message != NULL);
8479                   (*link_info->callbacks->reloc_dangerous)
8480                     (link_info, error_message,
8481                      input_bfd, input_section, (*parent)->address);
8482                   break;
8483                 case bfd_reloc_overflow:
8484                   (*link_info->callbacks->reloc_overflow)
8485                     (link_info, NULL,
8486                      bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8487                      (*parent)->howto->name, (*parent)->addend,
8488                      input_bfd, input_section, (*parent)->address);
8489                   break;
8490                 case bfd_reloc_outofrange:
8491                   /* PR ld/13730:
8492                      This error can result when processing some partially
8493                      complete binaries.  Do not abort, but issue an error
8494                      message instead.  */
8495                   link_info->callbacks->einfo
8496                     /* xgettext:c-format */
8497                     (_("%X%P: %pB(%pA): relocation \"%pR\" goes out of range\n"),
8498                      abfd, input_section, * parent);
8499                   goto error_return;
8500
8501                 case bfd_reloc_notsupported:
8502                   /* PR ld/17512
8503                      This error can result when processing a corrupt binary.
8504                      Do not abort.  Issue an error message instead.  */
8505                   link_info->callbacks->einfo
8506                     /* xgettext:c-format */
8507                     (_("%X%P: %pB(%pA): relocation \"%pR\" is not supported\n"),
8508                      abfd, input_section, * parent);
8509                   goto error_return;
8510
8511                 default:
8512                   /* PR 17512; file: 90c2a92e.
8513                      Report unexpected results, without aborting.  */
8514                   link_info->callbacks->einfo
8515                     /* xgettext:c-format */
8516                     (_("%X%P: %pB(%pA): relocation \"%pR\" returns an unrecognized value %x\n"),
8517                      abfd, input_section, * parent, r);
8518                   break;
8519                 }
8520
8521             }
8522         }
8523     }
8524
8525   free (reloc_vector);
8526   return data;
8527
8528  error_return:
8529   free (reloc_vector);
8530   if (orig_data == NULL)
8531     free (data);
8532   return NULL;
8533 }
8534
8535 /*
8536 INTERNAL_FUNCTION
8537         _bfd_generic_set_reloc
8538
8539 SYNOPSIS
8540         void _bfd_generic_set_reloc
8541           (bfd *abfd,
8542            sec_ptr section,
8543            arelent **relptr,
8544            unsigned int count);
8545
8546 DESCRIPTION
8547         Installs a new set of internal relocations in SECTION.
8548 */
8549
8550 void
8551 _bfd_generic_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
8552                         sec_ptr section,
8553                         arelent **relptr,
8554                         unsigned int count)
8555 {
8556   section->orelocation = relptr;
8557   section->reloc_count = count;
8558   if (count != 0)
8559     section->flags |= SEC_RELOC;
8560   else
8561     section->flags &= ~SEC_RELOC;
8562 }
8563
8564 /*
8565 INTERNAL_FUNCTION
8566         _bfd_unrecognized_reloc
8567
8568 SYNOPSIS
8569         bool _bfd_unrecognized_reloc
8570           (bfd * abfd,
8571            sec_ptr section,
8572            unsigned int r_type);
8573
8574 DESCRIPTION
8575         Reports an unrecognized reloc.
8576         Written as a function in order to reduce code duplication.
8577         Returns FALSE so that it can be called from a return statement.
8578 */
8579
8580 bool
8581 _bfd_unrecognized_reloc (bfd * abfd, sec_ptr section, unsigned int r_type)
8582 {
8583    /* xgettext:c-format */
8584   _bfd_error_handler (_("%pB: unrecognized relocation type %#x in section `%pA'"),
8585                       abfd, r_type, section);
8586
8587   /* PR 21803: Suggest the most likely cause of this error.  */
8588   _bfd_error_handler (_("is this version of the linker - %s - out of date ?"),
8589                       BFD_VERSION_STRING);
8590
8591   bfd_set_error (bfd_error_bad_value);
8592   return false;
8593 }
8594
8595 reloc_howto_type *
8596 _bfd_norelocs_bfd_reloc_type_lookup
8597     (bfd *abfd,
8598      bfd_reloc_code_real_type code ATTRIBUTE_UNUSED)
8599 {
8600   return (reloc_howto_type *) _bfd_ptr_bfd_null_error (abfd);
8601 }
8602
8603 reloc_howto_type *
8604 _bfd_norelocs_bfd_reloc_name_lookup (bfd *abfd,
8605                                      const char *reloc_name ATTRIBUTE_UNUSED)
8606 {
8607   return (reloc_howto_type *) _bfd_ptr_bfd_null_error (abfd);
8608 }
8609
8610 long
8611 _bfd_nodynamic_canonicalize_dynamic_reloc (bfd *abfd,
8612                                            arelent **relp ATTRIBUTE_UNUSED,
8613                                            asymbol **symp ATTRIBUTE_UNUSED)
8614 {
8615   return _bfd_long_bfd_n1_error (abfd);
8616 }