Subversion Repositories Kolibri OS

Rev

Rev 5197 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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