bfd/reloc.c

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