Subversion Repositories Kolibri OS

Rev

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

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