1/* BFD support for handling relocation entries.
2   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3   2000, 2001, 2002, 2003, 2004
4   Free Software Foundation, Inc.
5   Written by Cygnus Support.
6
7   This file is part of BFD, the Binary File Descriptor library.
8
9   This program is free software; you can redistribute it and/or modify
10   it under the terms of the GNU General Public License as published by
11   the Free Software Foundation; either version 2 of the License, or
12   (at your option) any later version.
13
14   This program is distributed in the hope that it will be useful,
15   but WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17   GNU General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with this program; if not, write to the Free Software
21   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
22
23/*
24SECTION
25	Relocations
26
27	BFD maintains relocations in much the same way it maintains
28	symbols: they are left alone until required, then read in
29	en-masse and translated into an internal form.  A common
30	routine <<bfd_perform_relocation>> acts upon the
31	canonical form to do the fixup.
32
33	Relocations are maintained on a per section basis,
34	while symbols are maintained on a per BFD basis.
35
36	All that a back end has to do to fit the BFD interface is to create
37	a <<struct reloc_cache_entry>> for each relocation
38	in a particular section, and fill in the right bits of the structures.
39
40@menu
41@* typedef arelent::
42@* howto manager::
43@end menu
44
45*/
46
47/* DO compile in the reloc_code name table from libbfd.h.  */
48#define _BFD_MAKE_TABLE_bfd_reloc_code_real
49
50#include "bfd.h"
51#include "sysdep.h"
52#include "bfdlink.h"
53#include "libbfd.h"
54/*
55DOCDD
56INODE
57	typedef arelent, howto manager, Relocations, Relocations
58
59SUBSECTION
60	typedef arelent
61
62	This is the structure of a relocation entry:
63
64CODE_FRAGMENT
65.
66.typedef enum bfd_reloc_status
67.{
68.  {* No errors detected.  *}
69.  bfd_reloc_ok,
70.
71.  {* The relocation was performed, but there was an overflow.  *}
72.  bfd_reloc_overflow,
73.
74.  {* The address to relocate was not within the section supplied.  *}
75.  bfd_reloc_outofrange,
76.
77.  {* Used by special functions.  *}
78.  bfd_reloc_continue,
79.
80.  {* Unsupported relocation size requested.  *}
81.  bfd_reloc_notsupported,
82.
83.  {* Unused.  *}
84.  bfd_reloc_other,
85.
86.  {* The symbol to relocate against was undefined.  *}
87.  bfd_reloc_undefined,
88.
89.  {* The relocation was performed, but may not be ok - presently
90.     generated only when linking i960 coff files with i960 b.out
91.     symbols.  If this type is returned, the error_message argument
92.     to bfd_perform_relocation will be set.  *}
93.  bfd_reloc_dangerous
94. }
95. bfd_reloc_status_type;
96.
97.
98.typedef struct reloc_cache_entry
99.{
100.  {* A pointer into the canonical table of pointers.  *}
101.  struct bfd_symbol **sym_ptr_ptr;
102.
103.  {* offset in section.  *}
104.  bfd_size_type address;
105.
106.  {* addend for relocation value.  *}
107.  bfd_vma addend;
108.
109.  {* Pointer to how to perform the required relocation.  *}
110.  reloc_howto_type *howto;
111.
112.}
113.arelent;
114.
115*/
116
117/*
118DESCRIPTION
119
120        Here is a description of each of the fields within an <<arelent>>:
121
122        o <<sym_ptr_ptr>>
123
124        The symbol table pointer points to a pointer to the symbol
125        associated with the relocation request.  It is the pointer
126        into the table returned by the back end's
127        <<canonicalize_symtab>> action. @xref{Symbols}. The symbol is
128        referenced through a pointer to a pointer so that tools like
129        the linker can fix up all the symbols of the same name by
130        modifying only one pointer. The relocation routine looks in
131        the symbol and uses the base of the section the symbol is
132        attached to and the value of the symbol as the initial
133        relocation offset. If the symbol pointer is zero, then the
134        section provided is looked up.
135
136        o <<address>>
137
138        The <<address>> field gives the offset in bytes from the base of
139        the section data which owns the relocation record to the first
140        byte of relocatable information. The actual data relocated
141        will be relative to this point; for example, a relocation
142        type which modifies the bottom two bytes of a four byte word
143        would not touch the first byte pointed to in a big endian
144        world.
145
146	o <<addend>>
147
148	The <<addend>> is a value provided by the back end to be added (!)
149	to the relocation offset. Its interpretation is dependent upon
150	the howto. For example, on the 68k the code:
151
152|        char foo[];
153|        main()
154|                {
155|                return foo[0x12345678];
156|                }
157
158        Could be compiled into:
159
160|        linkw fp,#-4
161|        moveb @@#12345678,d0
162|        extbl d0
163|        unlk fp
164|        rts
165
166        This could create a reloc pointing to <<foo>>, but leave the
167        offset in the data, something like:
168
169|RELOCATION RECORDS FOR [.text]:
170|offset   type      value
171|00000006 32        _foo
172|
173|00000000 4e56 fffc          ; linkw fp,#-4
174|00000004 1039 1234 5678     ; moveb @@#12345678,d0
175|0000000a 49c0               ; extbl d0
176|0000000c 4e5e               ; unlk fp
177|0000000e 4e75               ; rts
178
179        Using coff and an 88k, some instructions don't have enough
180        space in them to represent the full address range, and
181        pointers have to be loaded in two parts. So you'd get something like:
182
183|        or.u     r13,r0,hi16(_foo+0x12345678)
184|        ld.b     r2,r13,lo16(_foo+0x12345678)
185|        jmp      r1
186
187        This should create two relocs, both pointing to <<_foo>>, and with
188        0x12340000 in their addend field. The data would consist of:
189
190|RELOCATION RECORDS FOR [.text]:
191|offset   type      value
192|00000002 HVRT16    _foo+0x12340000
193|00000006 LVRT16    _foo+0x12340000
194|
195|00000000 5da05678           ; or.u r13,r0,0x5678
196|00000004 1c4d5678           ; ld.b r2,r13,0x5678
197|00000008 f400c001           ; jmp r1
198
199        The relocation routine digs out the value from the data, adds
200        it to the addend to get the original offset, and then adds the
201        value of <<_foo>>. Note that all 32 bits have to be kept around
202        somewhere, to cope with carry from bit 15 to bit 16.
203
204        One further example is the sparc and the a.out format. The
205        sparc has a similar problem to the 88k, in that some
206        instructions don't have room for an entire offset, but on the
207        sparc the parts are created in odd sized lumps. The designers of
208        the a.out format chose to not use the data within the section
209        for storing part of the offset; all the offset is kept within
210        the reloc. Anything in the data should be ignored.
211
212|        save %sp,-112,%sp
213|        sethi %hi(_foo+0x12345678),%g2
214|        ldsb [%g2+%lo(_foo+0x12345678)],%i0
215|        ret
216|        restore
217
218        Both relocs contain a pointer to <<foo>>, and the offsets
219        contain junk.
220
221|RELOCATION RECORDS FOR [.text]:
222|offset   type      value
223|00000004 HI22      _foo+0x12345678
224|00000008 LO10      _foo+0x12345678
225|
226|00000000 9de3bf90     ; save %sp,-112,%sp
227|00000004 05000000     ; sethi %hi(_foo+0),%g2
228|00000008 f048a000     ; ldsb [%g2+%lo(_foo+0)],%i0
229|0000000c 81c7e008     ; ret
230|00000010 81e80000     ; restore
231
232        o <<howto>>
233
234        The <<howto>> field can be imagined as a
235        relocation instruction. It is a pointer to a structure which
236        contains information on what to do with all of the other
237        information in the reloc record and data section. A back end
238        would normally have a relocation instruction set and turn
239        relocations into pointers to the correct structure on input -
240        but it would be possible to create each howto field on demand.
241
242*/
243
244/*
245SUBSUBSECTION
246	<<enum complain_overflow>>
247
248	Indicates what sort of overflow checking should be done when
249	performing a relocation.
250
251CODE_FRAGMENT
252.
253.enum complain_overflow
254.{
255.  {* Do not complain on overflow.  *}
256.  complain_overflow_dont,
257.
258.  {* Complain if the bitfield overflows, whether it is considered
259.     as signed or unsigned.  *}
260.  complain_overflow_bitfield,
261.
262.  {* Complain if the value overflows when considered as 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/*
274SUBSUBSECTION
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
280CODE_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.  {*  Notes that the relocation is relative to the location in the
307.      data section of the addend.  The relocation function will
308.      subtract from the relocation value the address of the location
309.      being relocated.  *}
310.  bfd_boolean pc_relative;
311.
312.  {*  The bit position of the reloc value in the destination.
313.      The relocated value is left shifted by this amount.  *}
314.  unsigned int bitpos;
315.
316.  {* What type of overflow error should be checked for when
317.     relocating.  *}
318.  enum complain_overflow complain_on_overflow;
319.
320.  {* If this field is non null, then the supplied function is
321.     called rather than the normal function.  This allows really
322.     strange relocation methods to be accommodated (e.g., i960 callj
323.     instructions).  *}
324.  bfd_reloc_status_type (*special_function)
325.    (bfd *, arelent *, struct bfd_symbol *, void *, asection *,
326.     bfd *, char **);
327.
328.  {* The textual name of the relocation type.  *}
329.  char *name;
330.
331.  {* Some formats record a relocation addend in the section contents
332.     rather than with the relocation.  For ELF formats this is the
333.     distinction between USE_REL and USE_RELA (though the code checks
334.     for USE_REL == 1/0).  The value of this field is TRUE if the
335.     addend is recorded with the section contents; when performing a
336.     partial link (ld -r) the section contents (the data) will be
337.     modified.  The value of this field is FALSE if addends are
338.     recorded with the relocation (in arelent.addend); when performing
339.     a partial link the relocation will be modified.
340.     All relocations for all ELF USE_RELA targets should set this field
341.     to FALSE (values of TRUE should be looked on with suspicion).
342.     However, the converse is not true: not all relocations of all ELF
343.     USE_REL targets set this field to TRUE.  Why this is so is peculiar
344.     to each particular target.  For relocs that aren't used in partial
345.     links (e.g. GOT stuff) it doesn't matter what this is set to.  *}
346.  bfd_boolean partial_inplace;
347.
348.  {* src_mask selects the part of the instruction (or data) to be used
349.     in the relocation sum.  If the target relocations don't have an
350.     addend in the reloc, eg. ELF USE_REL, src_mask will normally equal
351.     dst_mask to extract the addend from the section contents.  If
352.     relocations do have an addend in the reloc, eg. ELF USE_RELA, this
353.     field should be zero.  Non-zero values for ELF USE_RELA targets are
354.     bogus as in those cases the value in the dst_mask part of the
355.     section contents should be treated as garbage.  *}
356.  bfd_vma src_mask;
357.
358.  {* dst_mask selects which parts of the instruction (or data) are
359.     replaced with a relocated value.  *}
360.  bfd_vma dst_mask;
361.
362.  {* When some formats create PC relative instructions, they leave
363.     the value of the pc of the place being relocated in the offset
364.     slot of the instruction, so that a PC relative relocation can
365.     be made just by adding in an ordinary offset (e.g., sun3 a.out).
366.     Some formats leave the displacement part of an instruction
367.     empty (e.g., m88k bcs); this flag signals the fact.  *}
368.  bfd_boolean pcrel_offset;
369.};
370.
371*/
372
373/*
374FUNCTION
375	The HOWTO Macro
376
377DESCRIPTION
378	The HOWTO define is horrible and will go away.
379
380.#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
381.  { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }
382
383DESCRIPTION
384	And will be replaced with the totally magic way. But for the
385	moment, we are compatible, so do it this way.
386
387.#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \
388.  HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \
389.         NAME, FALSE, 0, 0, IN)
390.
391
392DESCRIPTION
393	This is used to fill in an empty howto entry in an array.
394
395.#define EMPTY_HOWTO(C) \
396.  HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \
397.         NULL, FALSE, 0, 0, FALSE)
398.
399
400DESCRIPTION
401	Helper routine to turn a symbol into a relocation value.
402
403.#define HOWTO_PREPARE(relocation, symbol)               \
404.  {                                                     \
405.    if (symbol != NULL)                                 \
406.      {                                                 \
407.        if (bfd_is_com_section (symbol->section))       \
408.          {                                             \
409.            relocation = 0;                             \
410.          }                                             \
411.        else                                            \
412.          {                                             \
413.            relocation = symbol->value;                 \
414.          }                                             \
415.      }                                                 \
416.  }
417.
418*/
419
420/*
421FUNCTION
422	bfd_get_reloc_size
423
424SYNOPSIS
425	unsigned int bfd_get_reloc_size (reloc_howto_type *);
426
427DESCRIPTION
428	For a reloc_howto_type that operates on a fixed number of bytes,
429	this returns the number of bytes operated on.
430 */
431
432unsigned int
433bfd_get_reloc_size (reloc_howto_type *howto)
434{
435  switch (howto->size)
436    {
437    case 0: return 1;
438    case 1: return 2;
439    case 2: return 4;
440    case 3: return 0;
441    case 4: return 8;
442    case 8: return 16;
443    case -2: return 4;
444    default: abort ();
445    }
446}
447
448/*
449TYPEDEF
450	arelent_chain
451
452DESCRIPTION
453
454	How relocs are tied together in an <<asection>>:
455
456.typedef struct relent_chain
457.{
458.  arelent relent;
459.  struct relent_chain *next;
460.}
461.arelent_chain;
462.
463*/
464
465/* N_ONES produces N one bits, without overflowing machine arithmetic.  */
466#define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
467
468/*
469FUNCTION
470	bfd_check_overflow
471
472SYNOPSIS
473	bfd_reloc_status_type bfd_check_overflow
474	  (enum complain_overflow how,
475	   unsigned int bitsize,
476	   unsigned int rightshift,
477	   unsigned int addrsize,
478	   bfd_vma relocation);
479
480DESCRIPTION
481	Perform overflow checking on @var{relocation} which has
482	@var{bitsize} significant bits and will be shifted right by
483	@var{rightshift} bits, on a machine with addresses containing
484	@var{addrsize} significant bits.  The result is either of
485	@code{bfd_reloc_ok} or @code{bfd_reloc_overflow}.
486
487*/
488
489bfd_reloc_status_type
490bfd_check_overflow (enum complain_overflow how,
491		    unsigned int bitsize,
492		    unsigned int rightshift,
493		    unsigned int addrsize,
494		    bfd_vma relocation)
495{
496  bfd_vma fieldmask, addrmask, signmask, ss, a;
497  bfd_reloc_status_type flag = bfd_reloc_ok;
498
499  a = relocation;
500
501  /* Note: BITSIZE should always be <= ADDRSIZE, but in case it's not,
502     we'll be permissive: extra bits in the field mask will
503     automatically extend the address mask for purposes of the
504     overflow check.  */
505  fieldmask = N_ONES (bitsize);
506  addrmask = N_ONES (addrsize) | fieldmask;
507
508  switch (how)
509    {
510    case complain_overflow_dont:
511      break;
512
513    case complain_overflow_signed:
514      /* If any sign bits are set, all sign bits must be set.  That
515         is, A must be a valid negative address after shifting.  */
516      a = (a & addrmask) >> rightshift;
517      signmask = ~ (fieldmask >> 1);
518      ss = a & signmask;
519      if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
520	flag = bfd_reloc_overflow;
521      break;
522
523    case complain_overflow_unsigned:
524      /* We have an overflow if the address does not fit in the field.  */
525      a = (a & addrmask) >> rightshift;
526      if ((a & ~ fieldmask) != 0)
527	flag = bfd_reloc_overflow;
528      break;
529
530    case complain_overflow_bitfield:
531      /* Bitfields are sometimes signed, sometimes unsigned.  We
532	 explicitly allow an address wrap too, which means a bitfield
533	 of n bits is allowed to store -2**n to 2**n-1.  Thus overflow
534	 if the value has some, but not all, bits set outside the
535	 field.  */
536      a >>= rightshift;
537      ss = a & ~ fieldmask;
538      if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & ~ fieldmask))
539	flag = bfd_reloc_overflow;
540      break;
541
542    default:
543      abort ();
544    }
545
546  return flag;
547}
548
549/*
550FUNCTION
551	bfd_perform_relocation
552
553SYNOPSIS
554	bfd_reloc_status_type bfd_perform_relocation
555          (bfd *abfd,
556           arelent *reloc_entry,
557           void *data,
558           asection *input_section,
559           bfd *output_bfd,
560	   char **error_message);
561
562DESCRIPTION
563	If @var{output_bfd} is supplied to this function, the
564	generated image will be relocatable; the relocations are
565	copied to the output file after they have been changed to
566	reflect the new state of the world. There are two ways of
567	reflecting the results of partial linkage in an output file:
568	by modifying the output data in place, and by modifying the
569	relocation record.  Some native formats (e.g., basic a.out and
570	basic coff) have no way of specifying an addend in the
571	relocation type, so the addend has to go in the output data.
572	This is no big deal since in these formats the output data
573	slot will always be big enough for the addend. Complex reloc
574	types with addends were invented to solve just this problem.
575	The @var{error_message} argument is set to an error message if
576	this return @code{bfd_reloc_dangerous}.
577
578*/
579
580bfd_reloc_status_type
581bfd_perform_relocation (bfd *abfd,
582			arelent *reloc_entry,
583			void *data,
584			asection *input_section,
585			bfd *output_bfd,
586			char **error_message)
587{
588  bfd_vma relocation;
589  bfd_reloc_status_type flag = bfd_reloc_ok;
590  bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
591  bfd_vma output_base = 0;
592  reloc_howto_type *howto = reloc_entry->howto;
593  asection *reloc_target_output_section;
594  asymbol *symbol;
595
596  symbol = *(reloc_entry->sym_ptr_ptr);
597  if (bfd_is_abs_section (symbol->section)
598      && output_bfd != NULL)
599    {
600      reloc_entry->address += input_section->output_offset;
601      return bfd_reloc_ok;
602    }
603
604  /* If we are not producing relocatable output, return an error if
605     the symbol is not defined.  An undefined weak symbol is
606     considered to have a value of zero (SVR4 ABI, p. 4-27).  */
607  if (bfd_is_und_section (symbol->section)
608      && (symbol->flags & BSF_WEAK) == 0
609      && output_bfd == NULL)
610    flag = bfd_reloc_undefined;
611
612  /* If there is a function supplied to handle this relocation type,
613     call it.  It'll return `bfd_reloc_continue' if further processing
614     can be done.  */
615  if (howto->special_function)
616    {
617      bfd_reloc_status_type cont;
618      cont = howto->special_function (abfd, reloc_entry, symbol, data,
619				      input_section, output_bfd,
620				      error_message);
621      if (cont != bfd_reloc_continue)
622	return cont;
623    }
624
625  /* Is the address of the relocation really within the section?  */
626  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
627    return bfd_reloc_outofrange;
628
629  /* Work out which section the relocation is targeted at and the
630     initial relocation command value.  */
631
632  /* Get symbol value.  (Common symbols are special.)  */
633  if (bfd_is_com_section (symbol->section))
634    relocation = 0;
635  else
636    relocation = symbol->value;
637
638  reloc_target_output_section = symbol->section->output_section;
639
640  /* Convert input-section-relative symbol value to absolute.  */
641  if ((output_bfd && ! howto->partial_inplace)
642      || reloc_target_output_section == NULL)
643    output_base = 0;
644  else
645    output_base = reloc_target_output_section->vma;
646
647  relocation += output_base + symbol->section->output_offset;
648
649  /* Add in supplied addend.  */
650  relocation += reloc_entry->addend;
651
652  /* Here the variable relocation holds the final address of the
653     symbol we are relocating against, plus any addend.  */
654
655  if (howto->pc_relative)
656    {
657      /* This is a PC relative relocation.  We want to set RELOCATION
658	 to the distance between the address of the symbol and the
659	 location.  RELOCATION is already the address of the symbol.
660
661	 We start by subtracting the address of the section containing
662	 the location.
663
664	 If pcrel_offset is set, we must further subtract the position
665	 of the location within the section.  Some targets arrange for
666	 the addend to be the negative of the position of the location
667	 within the section; for example, i386-aout does this.  For
668	 i386-aout, pcrel_offset is FALSE.  Some other targets do not
669	 include the position of the location; for example, m88kbcs,
670	 or ELF.  For those targets, pcrel_offset is TRUE.
671
672	 If we are producing relocatable output, then we must ensure
673	 that this reloc will be correctly computed when the final
674	 relocation is done.  If pcrel_offset is FALSE we want to wind
675	 up with the negative of the location within the section,
676	 which means we must adjust the existing addend by the change
677	 in the location within the section.  If pcrel_offset is TRUE
678	 we do not want to adjust the existing addend at all.
679
680	 FIXME: This seems logical to me, but for the case of
681	 producing relocatable output it is not what the code
682	 actually does.  I don't want to change it, because it seems
683	 far too likely that something will break.  */
684
685      relocation -=
686	input_section->output_section->vma + input_section->output_offset;
687
688      if (howto->pcrel_offset)
689	relocation -= reloc_entry->address;
690    }
691
692  if (output_bfd != NULL)
693    {
694      if (! howto->partial_inplace)
695	{
696	  /* This is a partial relocation, and we want to apply the relocation
697	     to the reloc entry rather than the raw data. Modify the reloc
698	     inplace to reflect what we now know.  */
699	  reloc_entry->addend = relocation;
700	  reloc_entry->address += input_section->output_offset;
701	  return flag;
702	}
703      else
704	{
705	  /* This is a partial relocation, but inplace, so modify the
706	     reloc record a bit.
707
708	     If we've relocated with a symbol with a section, change
709	     into a ref to the section belonging to the symbol.  */
710
711	  reloc_entry->address += input_section->output_offset;
712
713	  /* WTF?? */
714	  if (abfd->xvec->flavour == bfd_target_coff_flavour
715	      && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
716	      && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
717	    {
718#if 1
719	      /* For m68k-coff, the addend was being subtracted twice during
720		 relocation with -r.  Removing the line below this comment
721		 fixes that problem; see PR 2953.
722
723However, Ian wrote the following, regarding removing the line below,
724which explains why it is still enabled:  --djm
725
726If you put a patch like that into BFD you need to check all the COFF
727linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
728SCO); see coff_i386_reloc in coff-i386.c where I worked around the
729problem in a different way.  There may very well be a reason that the
730code works as it does.
731
732Hmmm.  The first obvious point is that bfd_perform_relocation should
733not have any tests that depend upon the flavour.  It's seem like
734entirely the wrong place for such a thing.  The second obvious point
735is that the current code ignores the reloc addend when producing
736relocatable output for COFF.  That's peculiar.  In fact, I really
737have no idea what the point of the line you want to remove is.
738
739A typical COFF reloc subtracts the old value of the symbol and adds in
740the new value to the location in the object file (if it's a pc
741relative reloc it adds the difference between the symbol value and the
742location).  When relocating we need to preserve that property.
743
744BFD handles this by setting the addend to the negative of the old
745value of the symbol.  Unfortunately it handles common symbols in a
746non-standard way (it doesn't subtract the old value) but that's a
747different story (we can't change it without losing backward
748compatibility with old object files) (coff-i386 does subtract the old
749value, to be compatible with existing coff-i386 targets, like SCO).
750
751So everything works fine when not producing relocatable output.  When
752we are producing relocatable output, logically we should do exactly
753what we do when not producing relocatable output.  Therefore, your
754patch is correct.  In fact, it should probably always just set
755reloc_entry->addend to 0 for all cases, since it is, in fact, going to
756add the value into the object file.  This won't hurt the COFF code,
757which doesn't use the addend; I'm not sure what it will do to other
758formats (the thing to check for would be whether any formats both use
759the addend and set partial_inplace).
760
761When I wanted to make coff-i386 produce relocatable output, I ran
762into the problem that you are running into: I wanted to remove that
763line.  Rather than risk it, I made the coff-i386 relocs use a special
764function; it's coff_i386_reloc in coff-i386.c.  The function
765specifically adds the addend field into the object file, knowing that
766bfd_perform_relocation is not going to.  If you remove that line, then
767coff-i386.c will wind up adding the addend field in twice.  It's
768trivial to fix; it just needs to be done.
769
770The problem with removing the line is just that it may break some
771working code.  With BFD it's hard to be sure of anything.  The right
772way to deal with this is simply to build and test at least all the
773supported COFF targets.  It should be straightforward if time and disk
774space consuming.  For each target:
775    1) build the linker
776    2) generate some executable, and link it using -r (I would
777       probably use paranoia.o and link against newlib/libc.a, which
778       for all the supported targets would be available in
779       /usr/cygnus/progressive/H-host/target/lib/libc.a).
780    3) make the change to reloc.c
781    4) rebuild the linker
782    5) repeat step 2
783    6) if the resulting object files are the same, you have at least
784       made it no worse
785    7) if they are different you have to figure out which version is
786       right
787*/
788	      relocation -= reloc_entry->addend;
789#endif
790	      reloc_entry->addend = 0;
791	    }
792	  else
793	    {
794	      reloc_entry->addend = relocation;
795	    }
796	}
797    }
798  else
799    {
800      reloc_entry->addend = 0;
801    }
802
803  /* FIXME: This overflow checking is incomplete, because the value
804     might have overflowed before we get here.  For a correct check we
805     need to compute the value in a size larger than bitsize, but we
806     can't reasonably do that for a reloc the same size as a host
807     machine word.
808     FIXME: We should also do overflow checking on the result after
809     adding in the value contained in the object file.  */
810  if (howto->complain_on_overflow != complain_overflow_dont
811      && flag == bfd_reloc_ok)
812    flag = bfd_check_overflow (howto->complain_on_overflow,
813			       howto->bitsize,
814			       howto->rightshift,
815			       bfd_arch_bits_per_address (abfd),
816			       relocation);
817
818  /* Either we are relocating all the way, or we don't want to apply
819     the relocation to the reloc entry (probably because there isn't
820     any room in the output format to describe addends to relocs).  */
821
822  /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
823     (OSF version 1.3, compiler version 3.11).  It miscompiles the
824     following program:
825
826     struct str
827     {
828       unsigned int i0;
829     } s = { 0 };
830
831     int
832     main ()
833     {
834       unsigned long x;
835
836       x = 0x100000000;
837       x <<= (unsigned long) s.i0;
838       if (x == 0)
839	 printf ("failed\n");
840       else
841	 printf ("succeeded (%lx)\n", x);
842     }
843     */
844
845  relocation >>= (bfd_vma) howto->rightshift;
846
847  /* Shift everything up to where it's going to be used.  */
848  relocation <<= (bfd_vma) howto->bitpos;
849
850  /* Wait for the day when all have the mask in them.  */
851
852  /* What we do:
853     i instruction to be left alone
854     o offset within instruction
855     r relocation offset to apply
856     S src mask
857     D dst mask
858     N ~dst mask
859     A part 1
860     B part 2
861     R result
862
863     Do this:
864     ((  i i i i i o o o o o  from bfd_get<size>
865     and           S S S S S) to get the size offset we want
866     +   r r r r r r r r r r) to get the final value to place
867     and           D D D D D  to chop to right size
868     -----------------------
869     =             A A A A A
870     And this:
871     (   i i i i i o o o o o  from bfd_get<size>
872     and N N N N N          ) get instruction
873     -----------------------
874     =   B B B B B
875
876     And then:
877     (   B B B B B
878     or            A A A A A)
879     -----------------------
880     =   R R R R R R R R R R  put into bfd_put<size>
881     */
882
883#define DOIT(x) \
884  x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
885
886  switch (howto->size)
887    {
888    case 0:
889      {
890	char x = bfd_get_8 (abfd, (char *) data + octets);
891	DOIT (x);
892	bfd_put_8 (abfd, x, (unsigned char *) data + octets);
893      }
894      break;
895
896    case 1:
897      {
898	short x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
899	DOIT (x);
900	bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + octets);
901      }
902      break;
903    case 2:
904      {
905	long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
906	DOIT (x);
907	bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
908      }
909      break;
910    case -2:
911      {
912	long x = bfd_get_32 (abfd, (bfd_byte *) data + octets);
913	relocation = -relocation;
914	DOIT (x);
915	bfd_put_32 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
916      }
917      break;
918
919    case -1:
920      {
921	long x = bfd_get_16 (abfd, (bfd_byte *) data + octets);
922	relocation = -relocation;
923	DOIT (x);
924	bfd_put_16 (abfd, (bfd_vma) x, (bfd_byte *) data + octets);
925      }
926      break;
927
928    case 3:
929      /* Do nothing */
930      break;
931
932    case 4:
933#ifdef BFD64
934      {
935	bfd_vma x = bfd_get_64 (abfd, (bfd_byte *) data + octets);
936	DOIT (x);
937	bfd_put_64 (abfd, x, (bfd_byte *) data + octets);
938      }
939#else
940      abort ();
941#endif
942      break;
943    default:
944      return bfd_reloc_other;
945    }
946
947  return flag;
948}
949
950/*
951FUNCTION
952	bfd_install_relocation
953
954SYNOPSIS
955	bfd_reloc_status_type bfd_install_relocation
956          (bfd *abfd,
957           arelent *reloc_entry,
958           void *data, bfd_vma data_start,
959           asection *input_section,
960	   char **error_message);
961
962DESCRIPTION
963	This looks remarkably like <<bfd_perform_relocation>>, except it
964	does not expect that the section contents have been filled in.
965	I.e., it's suitable for use when creating, rather than applying
966	a relocation.
967
968	For now, this function should be considered reserved for the
969	assembler.
970*/
971
972bfd_reloc_status_type
973bfd_install_relocation (bfd *abfd,
974			arelent *reloc_entry,
975			void *data_start,
976			bfd_vma data_start_offset,
977			asection *input_section,
978			char **error_message)
979{
980  bfd_vma relocation;
981  bfd_reloc_status_type flag = bfd_reloc_ok;
982  bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
983  bfd_vma output_base = 0;
984  reloc_howto_type *howto = reloc_entry->howto;
985  asection *reloc_target_output_section;
986  asymbol *symbol;
987  bfd_byte *data;
988
989  symbol = *(reloc_entry->sym_ptr_ptr);
990  if (bfd_is_abs_section (symbol->section))
991    {
992      reloc_entry->address += input_section->output_offset;
993      return bfd_reloc_ok;
994    }
995
996  /* If there is a function supplied to handle this relocation type,
997     call it.  It'll return `bfd_reloc_continue' if further processing
998     can be done.  */
999  if (howto->special_function)
1000    {
1001      bfd_reloc_status_type cont;
1002
1003      /* XXX - The special_function calls haven't been fixed up to deal
1004	 with creating new relocations and section contents.  */
1005      cont = howto->special_function (abfd, reloc_entry, symbol,
1006				      /* XXX - Non-portable! */
1007				      ((bfd_byte *) data_start
1008				       - data_start_offset),
1009				      input_section, abfd, error_message);
1010      if (cont != bfd_reloc_continue)
1011	return cont;
1012    }
1013
1014  /* Is the address of the relocation really within the section?  */
1015  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1016    return bfd_reloc_outofrange;
1017
1018  /* Work out which section the relocation is targeted at and the
1019     initial relocation command value.  */
1020
1021  /* Get symbol value.  (Common symbols are special.)  */
1022  if (bfd_is_com_section (symbol->section))
1023    relocation = 0;
1024  else
1025    relocation = symbol->value;
1026
1027  reloc_target_output_section = symbol->section->output_section;
1028
1029  /* Convert input-section-relative symbol value to absolute.  */
1030  if (! howto->partial_inplace)
1031    output_base = 0;
1032  else
1033    output_base = reloc_target_output_section->vma;
1034
1035  relocation += output_base + symbol->section->output_offset;
1036
1037  /* Add in supplied addend.  */
1038  relocation += reloc_entry->addend;
1039
1040  /* Here the variable relocation holds the final address of the
1041     symbol we are relocating against, plus any addend.  */
1042
1043  if (howto->pc_relative)
1044    {
1045      /* This is a PC relative relocation.  We want to set RELOCATION
1046	 to the distance between the address of the symbol and the
1047	 location.  RELOCATION is already the address of the symbol.
1048
1049	 We start by subtracting the address of the section containing
1050	 the location.
1051
1052	 If pcrel_offset is set, we must further subtract the position
1053	 of the location within the section.  Some targets arrange for
1054	 the addend to be the negative of the position of the location
1055	 within the section; for example, i386-aout does this.  For
1056	 i386-aout, pcrel_offset is FALSE.  Some other targets do not
1057	 include the position of the location; for example, m88kbcs,
1058	 or ELF.  For those targets, pcrel_offset is TRUE.
1059
1060	 If we are producing relocatable output, then we must ensure
1061	 that this reloc will be correctly computed when the final
1062	 relocation is done.  If pcrel_offset is FALSE we want to wind
1063	 up with the negative of the location within the section,
1064	 which means we must adjust the existing addend by the change
1065	 in the location within the section.  If pcrel_offset is TRUE
1066	 we do not want to adjust the existing addend at all.
1067
1068	 FIXME: This seems logical to me, but for the case of
1069	 producing relocatable output it is not what the code
1070	 actually does.  I don't want to change it, because it seems
1071	 far too likely that something will break.  */
1072
1073      relocation -=
1074	input_section->output_section->vma + input_section->output_offset;
1075
1076      if (howto->pcrel_offset && howto->partial_inplace)
1077	relocation -= reloc_entry->address;
1078    }
1079
1080  if (! howto->partial_inplace)
1081    {
1082      /* This is a partial relocation, and we want to apply the relocation
1083	 to the reloc entry rather than the raw data. Modify the reloc
1084	 inplace to reflect what we now know.  */
1085      reloc_entry->addend = relocation;
1086      reloc_entry->address += input_section->output_offset;
1087      return flag;
1088    }
1089  else
1090    {
1091      /* This is a partial relocation, but inplace, so modify the
1092	 reloc record a bit.
1093
1094	 If we've relocated with a symbol with a section, change
1095	 into a ref to the section belonging to the symbol.  */
1096      reloc_entry->address += input_section->output_offset;
1097
1098      /* WTF?? */
1099      if (abfd->xvec->flavour == bfd_target_coff_flavour
1100	  && strcmp (abfd->xvec->name, "coff-Intel-little") != 0
1101	  && strcmp (abfd->xvec->name, "coff-Intel-big") != 0)
1102	{
1103#if 1
1104/* For m68k-coff, the addend was being subtracted twice during
1105   relocation with -r.  Removing the line below this comment
1106   fixes that problem; see PR 2953.
1107
1108However, Ian wrote the following, regarding removing the line below,
1109which explains why it is still enabled:  --djm
1110
1111If you put a patch like that into BFD you need to check all the COFF
1112linkers.  I am fairly certain that patch will break coff-i386 (e.g.,
1113SCO); see coff_i386_reloc in coff-i386.c where I worked around the
1114problem in a different way.  There may very well be a reason that the
1115code works as it does.
1116
1117Hmmm.  The first obvious point is that bfd_install_relocation should
1118not have any tests that depend upon the flavour.  It's seem like
1119entirely the wrong place for such a thing.  The second obvious point
1120is that the current code ignores the reloc addend when producing
1121relocatable output for COFF.  That's peculiar.  In fact, I really
1122have no idea what the point of the line you want to remove is.
1123
1124A typical COFF reloc subtracts the old value of the symbol and adds in
1125the new value to the location in the object file (if it's a pc
1126relative reloc it adds the difference between the symbol value and the
1127location).  When relocating we need to preserve that property.
1128
1129BFD handles this by setting the addend to the negative of the old
1130value of the symbol.  Unfortunately it handles common symbols in a
1131non-standard way (it doesn't subtract the old value) but that's a
1132different story (we can't change it without losing backward
1133compatibility with old object files) (coff-i386 does subtract the old
1134value, to be compatible with existing coff-i386 targets, like SCO).
1135
1136So everything works fine when not producing relocatable output.  When
1137we are producing relocatable output, logically we should do exactly
1138what we do when not producing relocatable output.  Therefore, your
1139patch is correct.  In fact, it should probably always just set
1140reloc_entry->addend to 0 for all cases, since it is, in fact, going to
1141add the value into the object file.  This won't hurt the COFF code,
1142which doesn't use the addend; I'm not sure what it will do to other
1143formats (the thing to check for would be whether any formats both use
1144the addend and set partial_inplace).
1145
1146When I wanted to make coff-i386 produce relocatable output, I ran
1147into the problem that you are running into: I wanted to remove that
1148line.  Rather than risk it, I made the coff-i386 relocs use a special
1149function; it's coff_i386_reloc in coff-i386.c.  The function
1150specifically adds the addend field into the object file, knowing that
1151bfd_install_relocation is not going to.  If you remove that line, then
1152coff-i386.c will wind up adding the addend field in twice.  It's
1153trivial to fix; it just needs to be done.
1154
1155The problem with removing the line is just that it may break some
1156working code.  With BFD it's hard to be sure of anything.  The right
1157way to deal with this is simply to build and test at least all the
1158supported COFF targets.  It should be straightforward if time and disk
1159space consuming.  For each target:
1160    1) build the linker
1161    2) generate some executable, and link it using -r (I would
1162       probably use paranoia.o and link against newlib/libc.a, which
1163       for all the supported targets would be available in
1164       /usr/cygnus/progressive/H-host/target/lib/libc.a).
1165    3) make the change to reloc.c
1166    4) rebuild the linker
1167    5) repeat step 2
1168    6) if the resulting object files are the same, you have at least
1169       made it no worse
1170    7) if they are different you have to figure out which version is
1171       right.  */
1172	  relocation -= reloc_entry->addend;
1173#endif
1174	  reloc_entry->addend = 0;
1175	}
1176      else
1177	{
1178	  reloc_entry->addend = relocation;
1179	}
1180    }
1181
1182  /* FIXME: This overflow checking is incomplete, because the value
1183     might have overflowed before we get here.  For a correct check we
1184     need to compute the value in a size larger than bitsize, but we
1185     can't reasonably do that for a reloc the same size as a host
1186     machine word.
1187     FIXME: We should also do overflow checking on the result after
1188     adding in the value contained in the object file.  */
1189  if (howto->complain_on_overflow != complain_overflow_dont)
1190    flag = bfd_check_overflow (howto->complain_on_overflow,
1191			       howto->bitsize,
1192			       howto->rightshift,
1193			       bfd_arch_bits_per_address (abfd),
1194			       relocation);
1195
1196  /* Either we are relocating all the way, or we don't want to apply
1197     the relocation to the reloc entry (probably because there isn't
1198     any room in the output format to describe addends to relocs).  */
1199
1200  /* The cast to bfd_vma avoids a bug in the Alpha OSF/1 C compiler
1201     (OSF version 1.3, compiler version 3.11).  It miscompiles the
1202     following program:
1203
1204     struct str
1205     {
1206       unsigned int i0;
1207     } s = { 0 };
1208
1209     int
1210     main ()
1211     {
1212       unsigned long x;
1213
1214       x = 0x100000000;
1215       x <<= (unsigned long) s.i0;
1216       if (x == 0)
1217	 printf ("failed\n");
1218       else
1219	 printf ("succeeded (%lx)\n", x);
1220     }
1221     */
1222
1223  relocation >>= (bfd_vma) howto->rightshift;
1224
1225  /* Shift everything up to where it's going to be used.  */
1226  relocation <<= (bfd_vma) howto->bitpos;
1227
1228  /* Wait for the day when all have the mask in them.  */
1229
1230  /* What we do:
1231     i instruction to be left alone
1232     o offset within instruction
1233     r relocation offset to apply
1234     S src mask
1235     D dst mask
1236     N ~dst mask
1237     A part 1
1238     B part 2
1239     R result
1240
1241     Do this:
1242     ((  i i i i i o o o o o  from bfd_get<size>
1243     and           S S S S S) to get the size offset we want
1244     +   r r r r r r r r r r) to get the final value to place
1245     and           D D D D D  to chop to right size
1246     -----------------------
1247     =             A A A A A
1248     And this:
1249     (   i i i i i o o o o o  from bfd_get<size>
1250     and N N N N N          ) get instruction
1251     -----------------------
1252     =   B B B B B
1253
1254     And then:
1255     (   B B B B B
1256     or            A A A A A)
1257     -----------------------
1258     =   R R R R R R R R R R  put into bfd_put<size>
1259     */
1260
1261#define DOIT(x) \
1262  x = ( (x & ~howto->dst_mask) | (((x & howto->src_mask) +  relocation) & howto->dst_mask))
1263
1264  data = (bfd_byte *) data_start + (octets - data_start_offset);
1265
1266  switch (howto->size)
1267    {
1268    case 0:
1269      {
1270	char x = bfd_get_8 (abfd, data);
1271	DOIT (x);
1272	bfd_put_8 (abfd, x, data);
1273      }
1274      break;
1275
1276    case 1:
1277      {
1278	short x = bfd_get_16 (abfd, data);
1279	DOIT (x);
1280	bfd_put_16 (abfd, (bfd_vma) x, data);
1281      }
1282      break;
1283    case 2:
1284      {
1285	long x = bfd_get_32 (abfd, data);
1286	DOIT (x);
1287	bfd_put_32 (abfd, (bfd_vma) x, data);
1288      }
1289      break;
1290    case -2:
1291      {
1292	long x = bfd_get_32 (abfd, data);
1293	relocation = -relocation;
1294	DOIT (x);
1295	bfd_put_32 (abfd, (bfd_vma) x, data);
1296      }
1297      break;
1298
1299    case 3:
1300      /* Do nothing */
1301      break;
1302
1303    case 4:
1304      {
1305	bfd_vma x = bfd_get_64 (abfd, data);
1306	DOIT (x);
1307	bfd_put_64 (abfd, x, data);
1308      }
1309      break;
1310    default:
1311      return bfd_reloc_other;
1312    }
1313
1314  return flag;
1315}
1316
1317/* This relocation routine is used by some of the backend linkers.
1318   They do not construct asymbol or arelent structures, so there is no
1319   reason for them to use bfd_perform_relocation.  Also,
1320   bfd_perform_relocation is so hacked up it is easier to write a new
1321   function than to try to deal with it.
1322
1323   This routine does a final relocation.  Whether it is useful for a
1324   relocatable link depends upon how the object format defines
1325   relocations.
1326
1327   FIXME: This routine ignores any special_function in the HOWTO,
1328   since the existing special_function values have been written for
1329   bfd_perform_relocation.
1330
1331   HOWTO is the reloc howto information.
1332   INPUT_BFD is the BFD which the reloc applies to.
1333   INPUT_SECTION is the section which the reloc applies to.
1334   CONTENTS is the contents of the section.
1335   ADDRESS is the address of the reloc within INPUT_SECTION.
1336   VALUE is the value of the symbol the reloc refers to.
1337   ADDEND is the addend of the reloc.  */
1338
1339bfd_reloc_status_type
1340_bfd_final_link_relocate (reloc_howto_type *howto,
1341			  bfd *input_bfd,
1342			  asection *input_section,
1343			  bfd_byte *contents,
1344			  bfd_vma address,
1345			  bfd_vma value,
1346			  bfd_vma addend)
1347{
1348  bfd_vma relocation;
1349
1350  /* Sanity check the address.  */
1351  if (address > bfd_get_section_limit (input_bfd, input_section))
1352    return bfd_reloc_outofrange;
1353
1354  /* This function assumes that we are dealing with a basic relocation
1355     against a symbol.  We want to compute the value of the symbol to
1356     relocate to.  This is just VALUE, the value of the symbol, plus
1357     ADDEND, any addend associated with the reloc.  */
1358  relocation = value + addend;
1359
1360  /* If the relocation is PC relative, we want to set RELOCATION to
1361     the distance between the symbol (currently in RELOCATION) and the
1362     location we are relocating.  Some targets (e.g., i386-aout)
1363     arrange for the contents of the section to be the negative of the
1364     offset of the location within the section; for such targets
1365     pcrel_offset is FALSE.  Other targets (e.g., m88kbcs or ELF)
1366     simply leave the contents of the section as zero; for such
1367     targets pcrel_offset is TRUE.  If pcrel_offset is FALSE we do not
1368     need to subtract out the offset of the location within the
1369     section (which is just ADDRESS).  */
1370  if (howto->pc_relative)
1371    {
1372      relocation -= (input_section->output_section->vma
1373		     + input_section->output_offset);
1374      if (howto->pcrel_offset)
1375	relocation -= address;
1376    }
1377
1378  return _bfd_relocate_contents (howto, input_bfd, relocation,
1379				 contents + address);
1380}
1381
1382/* Relocate a given location using a given value and howto.  */
1383
1384bfd_reloc_status_type
1385_bfd_relocate_contents (reloc_howto_type *howto,
1386			bfd *input_bfd,
1387			bfd_vma relocation,
1388			bfd_byte *location)
1389{
1390  int size;
1391  bfd_vma x = 0;
1392  bfd_reloc_status_type flag;
1393  unsigned int rightshift = howto->rightshift;
1394  unsigned int bitpos = howto->bitpos;
1395
1396  /* If the size is negative, negate RELOCATION.  This isn't very
1397     general.  */
1398  if (howto->size < 0)
1399    relocation = -relocation;
1400
1401  /* Get the value we are going to relocate.  */
1402  size = bfd_get_reloc_size (howto);
1403  switch (size)
1404    {
1405    default:
1406    case 0:
1407      abort ();
1408    case 1:
1409      x = bfd_get_8 (input_bfd, location);
1410      break;
1411    case 2:
1412      x = bfd_get_16 (input_bfd, location);
1413      break;
1414    case 4:
1415      x = bfd_get_32 (input_bfd, location);
1416      break;
1417    case 8:
1418#ifdef BFD64
1419      x = bfd_get_64 (input_bfd, location);
1420#else
1421      abort ();
1422#endif
1423      break;
1424    }
1425
1426  /* Check for overflow.  FIXME: We may drop bits during the addition
1427     which we don't check for.  We must either check at every single
1428     operation, which would be tedious, or we must do the computations
1429     in a type larger than bfd_vma, which would be inefficient.  */
1430  flag = bfd_reloc_ok;
1431  if (howto->complain_on_overflow != complain_overflow_dont)
1432    {
1433      bfd_vma addrmask, fieldmask, signmask, ss;
1434      bfd_vma a, b, sum;
1435
1436      /* Get the values to be added together.  For signed and unsigned
1437         relocations, we assume that all values should be truncated to
1438         the size of an address.  For bitfields, all the bits matter.
1439         See also bfd_check_overflow.  */
1440      fieldmask = N_ONES (howto->bitsize);
1441      addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
1442      a = relocation;
1443      b = x & howto->src_mask;
1444
1445      switch (howto->complain_on_overflow)
1446	{
1447	case complain_overflow_signed:
1448	  a = (a & addrmask) >> rightshift;
1449
1450	  /* If any sign bits are set, all sign bits must be set.
1451	     That is, A must be a valid negative address after
1452	     shifting.  */
1453	  signmask = ~ (fieldmask >> 1);
1454	  ss = a & signmask;
1455	  if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
1456	    flag = bfd_reloc_overflow;
1457
1458	  /* We only need this next bit of code if the sign bit of B
1459             is below the sign bit of A.  This would only happen if
1460             SRC_MASK had fewer bits than BITSIZE.  Note that if
1461             SRC_MASK has more bits than BITSIZE, we can get into
1462             trouble; we would need to verify that B is in range, as
1463             we do for A above.  */
1464	  signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1465
1466	  /* Set all the bits above the sign bit.  */
1467	  b = (b ^ signmask) - signmask;
1468
1469	  b = (b & addrmask) >> bitpos;
1470
1471	  /* Now we can do the addition.  */
1472	  sum = a + b;
1473
1474	  /* See if the result has the correct sign.  Bits above the
1475             sign bit are junk now; ignore them.  If the sum is
1476             positive, make sure we did not have all negative inputs;
1477             if the sum is negative, make sure we did not have all
1478             positive inputs.  The test below looks only at the sign
1479             bits, and it really just
1480	         SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
1481	     */
1482	  signmask = (fieldmask >> 1) + 1;
1483	  if (((~ (a ^ b)) & (a ^ sum)) & signmask)
1484	    flag = bfd_reloc_overflow;
1485
1486	  break;
1487
1488	case complain_overflow_unsigned:
1489	  /* Checking for an unsigned overflow is relatively easy:
1490             trim the addresses and add, and trim the result as well.
1491             Overflow is normally indicated when the result does not
1492             fit in the field.  However, we also need to consider the
1493             case when, e.g., fieldmask is 0x7fffffff or smaller, an
1494             input is 0x80000000, and bfd_vma is only 32 bits; then we
1495             will get sum == 0, but there is an overflow, since the
1496             inputs did not fit in the field.  Instead of doing a
1497             separate test, we can check for this by or-ing in the
1498             operands when testing for the sum overflowing its final
1499             field.  */
1500	  a = (a & addrmask) >> rightshift;
1501	  b = (b & addrmask) >> bitpos;
1502	  sum = (a + b) & addrmask;
1503	  if ((a | b | sum) & ~ fieldmask)
1504	    flag = bfd_reloc_overflow;
1505
1506	  break;
1507
1508	case complain_overflow_bitfield:
1509	  /* Much like the signed check, but for a field one bit
1510	     wider, and no trimming inputs with addrmask.  We allow a
1511	     bitfield to represent numbers in the range -2**n to
1512	     2**n-1, where n is the number of bits in the field.
1513	     Note that when bfd_vma is 32 bits, a 32-bit reloc can't
1514	     overflow, which is exactly what we want.  */
1515	  a >>= rightshift;
1516
1517	  signmask = ~ fieldmask;
1518	  ss = a & signmask;
1519	  if (ss != 0 && ss != (((bfd_vma) -1 >> rightshift) & signmask))
1520	    flag = bfd_reloc_overflow;
1521
1522	  signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
1523	  b = (b ^ signmask) - signmask;
1524
1525	  b >>= bitpos;
1526
1527	  sum = a + b;
1528
1529	  /* We mask with addrmask here to explicitly allow an address
1530	     wrap-around.  The Linux kernel relies on it, and it is
1531	     the only way to write assembler code which can run when
1532	     loaded at a location 0x80000000 away from the location at
1533	     which it is linked.  */
1534	  signmask = fieldmask + 1;
1535	  if (((~ (a ^ b)) & (a ^ sum)) & signmask & addrmask)
1536	    flag = bfd_reloc_overflow;
1537
1538	  break;
1539
1540	default:
1541	  abort ();
1542	}
1543    }
1544
1545  /* Put RELOCATION in the right bits.  */
1546  relocation >>= (bfd_vma) rightshift;
1547  relocation <<= (bfd_vma) bitpos;
1548
1549  /* Add RELOCATION to the right bits of X.  */
1550  x = ((x & ~howto->dst_mask)
1551       | (((x & howto->src_mask) + relocation) & howto->dst_mask));
1552
1553  /* Put the relocated value back in the object file.  */
1554  switch (size)
1555    {
1556    default:
1557    case 0:
1558      abort ();
1559    case 1:
1560      bfd_put_8 (input_bfd, x, location);
1561      break;
1562    case 2:
1563      bfd_put_16 (input_bfd, x, location);
1564      break;
1565    case 4:
1566      bfd_put_32 (input_bfd, x, location);
1567      break;
1568    case 8:
1569#ifdef BFD64
1570      bfd_put_64 (input_bfd, x, location);
1571#else
1572      abort ();
1573#endif
1574      break;
1575    }
1576
1577  return flag;
1578}
1579
1580/*
1581DOCDD
1582INODE
1583	howto manager,  , typedef arelent, Relocations
1584
1585SECTION
1586	The howto manager
1587
1588	When an application wants to create a relocation, but doesn't
1589	know what the target machine might call it, it can find out by
1590	using this bit of code.
1591
1592*/
1593
1594/*
1595TYPEDEF
1596	bfd_reloc_code_type
1597
1598DESCRIPTION
1599	The insides of a reloc code.  The idea is that, eventually, there
1600	will be one enumerator for every type of relocation we ever do.
1601	Pass one of these values to <<bfd_reloc_type_lookup>>, and it'll
1602	return a howto pointer.
1603
1604	This does mean that the application must determine the correct
1605	enumerator value; you can't get a howto pointer from a random set
1606	of attributes.
1607
1608SENUM
1609   bfd_reloc_code_real
1610
1611ENUM
1612  BFD_RELOC_64
1613ENUMX
1614  BFD_RELOC_32
1615ENUMX
1616  BFD_RELOC_26
1617ENUMX
1618  BFD_RELOC_24
1619ENUMX
1620  BFD_RELOC_16
1621ENUMX
1622  BFD_RELOC_14
1623ENUMX
1624  BFD_RELOC_8
1625ENUMDOC
1626  Basic absolute relocations of N bits.
1627
1628ENUM
1629  BFD_RELOC_64_PCREL
1630ENUMX
1631  BFD_RELOC_32_PCREL
1632ENUMX
1633  BFD_RELOC_24_PCREL
1634ENUMX
1635  BFD_RELOC_16_PCREL
1636ENUMX
1637  BFD_RELOC_12_PCREL
1638ENUMX
1639  BFD_RELOC_8_PCREL
1640ENUMDOC
1641  PC-relative relocations.  Sometimes these are relative to the address
1642of the relocation itself; sometimes they are relative to the start of
1643the section containing the relocation.  It depends on the specific target.
1644
1645The 24-bit relocation is used in some Intel 960 configurations.
1646
1647ENUM
1648  BFD_RELOC_32_SECREL
1649ENUMDOC
1650  Section relative relocations.  Some targets need this for DWARF2.
1651
1652ENUM
1653  BFD_RELOC_32_GOT_PCREL
1654ENUMX
1655  BFD_RELOC_16_GOT_PCREL
1656ENUMX
1657  BFD_RELOC_8_GOT_PCREL
1658ENUMX
1659  BFD_RELOC_32_GOTOFF
1660ENUMX
1661  BFD_RELOC_16_GOTOFF
1662ENUMX
1663  BFD_RELOC_LO16_GOTOFF
1664ENUMX
1665  BFD_RELOC_HI16_GOTOFF
1666ENUMX
1667  BFD_RELOC_HI16_S_GOTOFF
1668ENUMX
1669  BFD_RELOC_8_GOTOFF
1670ENUMX
1671  BFD_RELOC_64_PLT_PCREL
1672ENUMX
1673  BFD_RELOC_32_PLT_PCREL
1674ENUMX
1675  BFD_RELOC_24_PLT_PCREL
1676ENUMX
1677  BFD_RELOC_16_PLT_PCREL
1678ENUMX
1679  BFD_RELOC_8_PLT_PCREL
1680ENUMX
1681  BFD_RELOC_64_PLTOFF
1682ENUMX
1683  BFD_RELOC_32_PLTOFF
1684ENUMX
1685  BFD_RELOC_16_PLTOFF
1686ENUMX
1687  BFD_RELOC_LO16_PLTOFF
1688ENUMX
1689  BFD_RELOC_HI16_PLTOFF
1690ENUMX
1691  BFD_RELOC_HI16_S_PLTOFF
1692ENUMX
1693  BFD_RELOC_8_PLTOFF
1694ENUMDOC
1695  For ELF.
1696
1697ENUM
1698  BFD_RELOC_68K_GLOB_DAT
1699ENUMX
1700  BFD_RELOC_68K_JMP_SLOT
1701ENUMX
1702  BFD_RELOC_68K_RELATIVE
1703ENUMDOC
1704  Relocations used by 68K ELF.
1705
1706ENUM
1707  BFD_RELOC_32_BASEREL
1708ENUMX
1709  BFD_RELOC_16_BASEREL
1710ENUMX
1711  BFD_RELOC_LO16_BASEREL
1712ENUMX
1713  BFD_RELOC_HI16_BASEREL
1714ENUMX
1715  BFD_RELOC_HI16_S_BASEREL
1716ENUMX
1717  BFD_RELOC_8_BASEREL
1718ENUMX
1719  BFD_RELOC_RVA
1720ENUMDOC
1721  Linkage-table relative.
1722
1723ENUM
1724  BFD_RELOC_8_FFnn
1725ENUMDOC
1726  Absolute 8-bit relocation, but used to form an address like 0xFFnn.
1727
1728ENUM
1729  BFD_RELOC_32_PCREL_S2
1730ENUMX
1731  BFD_RELOC_16_PCREL_S2
1732ENUMX
1733  BFD_RELOC_23_PCREL_S2
1734ENUMDOC
1735  These PC-relative relocations are stored as word displacements --
1736i.e., byte displacements shifted right two bits.  The 30-bit word
1737displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1738SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
1739signed 16-bit displacement is used on the MIPS, and the 23-bit
1740displacement is used on the Alpha.
1741
1742ENUM
1743  BFD_RELOC_HI22
1744ENUMX
1745  BFD_RELOC_LO10
1746ENUMDOC
1747  High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1748the target word.  These are used on the SPARC.
1749
1750ENUM
1751  BFD_RELOC_GPREL16
1752ENUMX
1753  BFD_RELOC_GPREL32
1754ENUMDOC
1755  For systems that allocate a Global Pointer register, these are
1756displacements off that register.  These relocation types are
1757handled specially, because the value the register will have is
1758decided relatively late.
1759
1760ENUM
1761  BFD_RELOC_I960_CALLJ
1762ENUMDOC
1763  Reloc types used for i960/b.out.
1764
1765ENUM
1766  BFD_RELOC_NONE
1767ENUMX
1768  BFD_RELOC_SPARC_WDISP22
1769ENUMX
1770  BFD_RELOC_SPARC22
1771ENUMX
1772  BFD_RELOC_SPARC13
1773ENUMX
1774  BFD_RELOC_SPARC_GOT10
1775ENUMX
1776  BFD_RELOC_SPARC_GOT13
1777ENUMX
1778  BFD_RELOC_SPARC_GOT22
1779ENUMX
1780  BFD_RELOC_SPARC_PC10
1781ENUMX
1782  BFD_RELOC_SPARC_PC22
1783ENUMX
1784  BFD_RELOC_SPARC_WPLT30
1785ENUMX
1786  BFD_RELOC_SPARC_COPY
1787ENUMX
1788  BFD_RELOC_SPARC_GLOB_DAT
1789ENUMX
1790  BFD_RELOC_SPARC_JMP_SLOT
1791ENUMX
1792  BFD_RELOC_SPARC_RELATIVE
1793ENUMX
1794  BFD_RELOC_SPARC_UA16
1795ENUMX
1796  BFD_RELOC_SPARC_UA32
1797ENUMX
1798  BFD_RELOC_SPARC_UA64
1799ENUMDOC
1800  SPARC ELF relocations.  There is probably some overlap with other
1801  relocation types already defined.
1802
1803ENUM
1804  BFD_RELOC_SPARC_BASE13
1805ENUMX
1806  BFD_RELOC_SPARC_BASE22
1807ENUMDOC
1808  I think these are specific to SPARC a.out (e.g., Sun 4).
1809
1810ENUMEQ
1811  BFD_RELOC_SPARC_64
1812  BFD_RELOC_64
1813ENUMX
1814  BFD_RELOC_SPARC_10
1815ENUMX
1816  BFD_RELOC_SPARC_11
1817ENUMX
1818  BFD_RELOC_SPARC_OLO10
1819ENUMX
1820  BFD_RELOC_SPARC_HH22
1821ENUMX
1822  BFD_RELOC_SPARC_HM10
1823ENUMX
1824  BFD_RELOC_SPARC_LM22
1825ENUMX
1826  BFD_RELOC_SPARC_PC_HH22
1827ENUMX
1828  BFD_RELOC_SPARC_PC_HM10
1829ENUMX
1830  BFD_RELOC_SPARC_PC_LM22
1831ENUMX
1832  BFD_RELOC_SPARC_WDISP16
1833ENUMX
1834  BFD_RELOC_SPARC_WDISP19
1835ENUMX
1836  BFD_RELOC_SPARC_7
1837ENUMX
1838  BFD_RELOC_SPARC_6
1839ENUMX
1840  BFD_RELOC_SPARC_5
1841ENUMEQX
1842  BFD_RELOC_SPARC_DISP64
1843  BFD_RELOC_64_PCREL
1844ENUMX
1845  BFD_RELOC_SPARC_PLT32
1846ENUMX
1847  BFD_RELOC_SPARC_PLT64
1848ENUMX
1849  BFD_RELOC_SPARC_HIX22
1850ENUMX
1851  BFD_RELOC_SPARC_LOX10
1852ENUMX
1853  BFD_RELOC_SPARC_H44
1854ENUMX
1855  BFD_RELOC_SPARC_M44
1856ENUMX
1857  BFD_RELOC_SPARC_L44
1858ENUMX
1859  BFD_RELOC_SPARC_REGISTER
1860ENUMDOC
1861  SPARC64 relocations
1862
1863ENUM
1864  BFD_RELOC_SPARC_REV32
1865ENUMDOC
1866  SPARC little endian relocation
1867ENUM
1868  BFD_RELOC_SPARC_TLS_GD_HI22
1869ENUMX
1870  BFD_RELOC_SPARC_TLS_GD_LO10
1871ENUMX
1872  BFD_RELOC_SPARC_TLS_GD_ADD
1873ENUMX
1874  BFD_RELOC_SPARC_TLS_GD_CALL
1875ENUMX
1876  BFD_RELOC_SPARC_TLS_LDM_HI22
1877ENUMX
1878  BFD_RELOC_SPARC_TLS_LDM_LO10
1879ENUMX
1880  BFD_RELOC_SPARC_TLS_LDM_ADD
1881ENUMX
1882  BFD_RELOC_SPARC_TLS_LDM_CALL
1883ENUMX
1884  BFD_RELOC_SPARC_TLS_LDO_HIX22
1885ENUMX
1886  BFD_RELOC_SPARC_TLS_LDO_LOX10
1887ENUMX
1888  BFD_RELOC_SPARC_TLS_LDO_ADD
1889ENUMX
1890  BFD_RELOC_SPARC_TLS_IE_HI22
1891ENUMX
1892  BFD_RELOC_SPARC_TLS_IE_LO10
1893ENUMX
1894  BFD_RELOC_SPARC_TLS_IE_LD
1895ENUMX
1896  BFD_RELOC_SPARC_TLS_IE_LDX
1897ENUMX
1898  BFD_RELOC_SPARC_TLS_IE_ADD
1899ENUMX
1900  BFD_RELOC_SPARC_TLS_LE_HIX22
1901ENUMX
1902  BFD_RELOC_SPARC_TLS_LE_LOX10
1903ENUMX
1904  BFD_RELOC_SPARC_TLS_DTPMOD32
1905ENUMX
1906  BFD_RELOC_SPARC_TLS_DTPMOD64
1907ENUMX
1908  BFD_RELOC_SPARC_TLS_DTPOFF32
1909ENUMX
1910  BFD_RELOC_SPARC_TLS_DTPOFF64
1911ENUMX
1912  BFD_RELOC_SPARC_TLS_TPOFF32
1913ENUMX
1914  BFD_RELOC_SPARC_TLS_TPOFF64
1915ENUMDOC
1916  SPARC TLS relocations
1917
1918ENUM
1919  BFD_RELOC_ALPHA_GPDISP_HI16
1920ENUMDOC
1921  Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
1922     "addend" in some special way.
1923  For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1924     writing; when reading, it will be the absolute section symbol.  The
1925     addend is the displacement in bytes of the "lda" instruction from
1926     the "ldah" instruction (which is at the address of this reloc).
1927ENUM
1928  BFD_RELOC_ALPHA_GPDISP_LO16
1929ENUMDOC
1930  For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1931     with GPDISP_HI16 relocs.  The addend is ignored when writing the
1932     relocations out, and is filled in with the file's GP value on
1933     reading, for convenience.
1934
1935ENUM
1936  BFD_RELOC_ALPHA_GPDISP
1937ENUMDOC
1938  The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1939     relocation except that there is no accompanying GPDISP_LO16
1940     relocation.
1941
1942ENUM
1943  BFD_RELOC_ALPHA_LITERAL
1944ENUMX
1945  BFD_RELOC_ALPHA_ELF_LITERAL
1946ENUMX
1947  BFD_RELOC_ALPHA_LITUSE
1948ENUMDOC
1949  The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1950     the assembler turns it into a LDQ instruction to load the address of
1951     the symbol, and then fills in a register in the real instruction.
1952
1953     The LITERAL reloc, at the LDQ instruction, refers to the .lita
1954     section symbol.  The addend is ignored when writing, but is filled
1955     in with the file's GP value on reading, for convenience, as with the
1956     GPDISP_LO16 reloc.
1957
1958     The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1959     It should refer to the symbol to be referenced, as with 16_GOTOFF,
1960     but it generates output not based on the position within the .got
1961     section, but relative to the GP value chosen for the file during the
1962     final link stage.
1963
1964     The LITUSE reloc, on the instruction using the loaded address, gives
1965     information to the linker that it might be able to use to optimize
1966     away some literal section references.  The symbol is ignored (read
1967     as the absolute section symbol), and the "addend" indicates the type
1968     of instruction using the register:
1969              1 - "memory" fmt insn
1970              2 - byte-manipulation (byte offset reg)
1971              3 - jsr (target of branch)
1972
1973ENUM
1974  BFD_RELOC_ALPHA_HINT
1975ENUMDOC
1976  The HINT relocation indicates a value that should be filled into the
1977     "hint" field of a jmp/jsr/ret instruction, for possible branch-
1978     prediction logic which may be provided on some processors.
1979
1980ENUM
1981  BFD_RELOC_ALPHA_LINKAGE
1982ENUMDOC
1983  The LINKAGE relocation outputs a linkage pair in the object file,
1984     which is filled by the linker.
1985
1986ENUM
1987  BFD_RELOC_ALPHA_CODEADDR
1988ENUMDOC
1989  The CODEADDR relocation outputs a STO_CA in the object file,
1990     which is filled by the linker.
1991
1992ENUM
1993  BFD_RELOC_ALPHA_GPREL_HI16
1994ENUMX
1995  BFD_RELOC_ALPHA_GPREL_LO16
1996ENUMDOC
1997  The GPREL_HI/LO relocations together form a 32-bit offset from the
1998     GP register.
1999
2000ENUM
2001  BFD_RELOC_ALPHA_BRSGP
2002ENUMDOC
2003  Like BFD_RELOC_23_PCREL_S2, except that the source and target must
2004  share a common GP, and the target address is adjusted for
2005  STO_ALPHA_STD_GPLOAD.
2006
2007ENUM
2008  BFD_RELOC_ALPHA_TLSGD
2009ENUMX
2010  BFD_RELOC_ALPHA_TLSLDM
2011ENUMX
2012  BFD_RELOC_ALPHA_DTPMOD64
2013ENUMX
2014  BFD_RELOC_ALPHA_GOTDTPREL16
2015ENUMX
2016  BFD_RELOC_ALPHA_DTPREL64
2017ENUMX
2018  BFD_RELOC_ALPHA_DTPREL_HI16
2019ENUMX
2020  BFD_RELOC_ALPHA_DTPREL_LO16
2021ENUMX
2022  BFD_RELOC_ALPHA_DTPREL16
2023ENUMX
2024  BFD_RELOC_ALPHA_GOTTPREL16
2025ENUMX
2026  BFD_RELOC_ALPHA_TPREL64
2027ENUMX
2028  BFD_RELOC_ALPHA_TPREL_HI16
2029ENUMX
2030  BFD_RELOC_ALPHA_TPREL_LO16
2031ENUMX
2032  BFD_RELOC_ALPHA_TPREL16
2033ENUMDOC
2034  Alpha thread-local storage relocations.
2035
2036ENUM
2037  BFD_RELOC_MIPS_JMP
2038ENUMDOC
2039  Bits 27..2 of the relocation address shifted right 2 bits;
2040     simple reloc otherwise.
2041
2042ENUM
2043  BFD_RELOC_MIPS16_JMP
2044ENUMDOC
2045  The MIPS16 jump instruction.
2046
2047ENUM
2048  BFD_RELOC_MIPS16_GPREL
2049ENUMDOC
2050  MIPS16 GP relative reloc.
2051
2052ENUM
2053  BFD_RELOC_HI16
2054ENUMDOC
2055  High 16 bits of 32-bit value; simple reloc.
2056ENUM
2057  BFD_RELOC_HI16_S
2058ENUMDOC
2059  High 16 bits of 32-bit value but the low 16 bits will be sign
2060     extended and added to form the final result.  If the low 16
2061     bits form a negative number, we need to add one to the high value
2062     to compensate for the borrow when the low bits are added.
2063ENUM
2064  BFD_RELOC_LO16
2065ENUMDOC
2066  Low 16 bits.
2067
2068ENUM
2069  BFD_RELOC_MIPS_LITERAL
2070ENUMDOC
2071  Relocation against a MIPS literal section.
2072
2073ENUM
2074  BFD_RELOC_MIPS_GOT16
2075ENUMX
2076  BFD_RELOC_MIPS_CALL16
2077ENUMX
2078  BFD_RELOC_MIPS_GOT_HI16
2079ENUMX
2080  BFD_RELOC_MIPS_GOT_LO16
2081ENUMX
2082  BFD_RELOC_MIPS_CALL_HI16
2083ENUMX
2084  BFD_RELOC_MIPS_CALL_LO16
2085ENUMX
2086  BFD_RELOC_MIPS_SUB
2087ENUMX
2088  BFD_RELOC_MIPS_GOT_PAGE
2089ENUMX
2090  BFD_RELOC_MIPS_GOT_OFST
2091ENUMX
2092  BFD_RELOC_MIPS_GOT_DISP
2093ENUMX
2094  BFD_RELOC_MIPS_SHIFT5
2095ENUMX
2096  BFD_RELOC_MIPS_SHIFT6
2097ENUMX
2098  BFD_RELOC_MIPS_INSERT_A
2099ENUMX
2100  BFD_RELOC_MIPS_INSERT_B
2101ENUMX
2102  BFD_RELOC_MIPS_DELETE
2103ENUMX
2104  BFD_RELOC_MIPS_HIGHEST
2105ENUMX
2106  BFD_RELOC_MIPS_HIGHER
2107ENUMX
2108  BFD_RELOC_MIPS_SCN_DISP
2109ENUMX
2110  BFD_RELOC_MIPS_REL16
2111ENUMX
2112  BFD_RELOC_MIPS_RELGOT
2113ENUMX
2114  BFD_RELOC_MIPS_JALR
2115ENUMDOC
2116  MIPS ELF relocations.
2117COMMENT
2118
2119ENUM
2120  BFD_RELOC_FRV_LABEL16
2121ENUMX
2122  BFD_RELOC_FRV_LABEL24
2123ENUMX
2124  BFD_RELOC_FRV_LO16
2125ENUMX
2126  BFD_RELOC_FRV_HI16
2127ENUMX
2128  BFD_RELOC_FRV_GPREL12
2129ENUMX
2130  BFD_RELOC_FRV_GPRELU12
2131ENUMX
2132  BFD_RELOC_FRV_GPREL32
2133ENUMX
2134  BFD_RELOC_FRV_GPRELHI
2135ENUMX
2136  BFD_RELOC_FRV_GPRELLO
2137ENUMX
2138  BFD_RELOC_FRV_GOT12
2139ENUMX
2140  BFD_RELOC_FRV_GOTHI
2141ENUMX
2142  BFD_RELOC_FRV_GOTLO
2143ENUMX
2144  BFD_RELOC_FRV_FUNCDESC
2145ENUMX
2146  BFD_RELOC_FRV_FUNCDESC_GOT12
2147ENUMX
2148  BFD_RELOC_FRV_FUNCDESC_GOTHI
2149ENUMX
2150  BFD_RELOC_FRV_FUNCDESC_GOTLO
2151ENUMX
2152  BFD_RELOC_FRV_FUNCDESC_VALUE
2153ENUMX
2154  BFD_RELOC_FRV_FUNCDESC_GOTOFF12
2155ENUMX
2156  BFD_RELOC_FRV_FUNCDESC_GOTOFFHI
2157ENUMX
2158  BFD_RELOC_FRV_FUNCDESC_GOTOFFLO
2159ENUMX
2160  BFD_RELOC_FRV_GOTOFF12
2161ENUMX
2162  BFD_RELOC_FRV_GOTOFFHI
2163ENUMX
2164  BFD_RELOC_FRV_GOTOFFLO
2165ENUMDOC
2166  Fujitsu Frv Relocations.
2167COMMENT
2168
2169ENUM
2170  BFD_RELOC_MN10300_GOTOFF24
2171ENUMDOC
2172  This is a 24bit GOT-relative reloc for the mn10300.
2173ENUM
2174  BFD_RELOC_MN10300_GOT32
2175ENUMDOC
2176  This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes
2177  in the instruction.
2178ENUM
2179  BFD_RELOC_MN10300_GOT24
2180ENUMDOC
2181  This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes
2182  in the instruction.
2183ENUM
2184  BFD_RELOC_MN10300_GOT16
2185ENUMDOC
2186  This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes
2187  in the instruction.
2188ENUM
2189  BFD_RELOC_MN10300_COPY
2190ENUMDOC
2191  Copy symbol at runtime.
2192ENUM
2193  BFD_RELOC_MN10300_GLOB_DAT
2194ENUMDOC
2195  Create GOT entry.
2196ENUM
2197  BFD_RELOC_MN10300_JMP_SLOT
2198ENUMDOC
2199  Create PLT entry.
2200ENUM
2201  BFD_RELOC_MN10300_RELATIVE
2202ENUMDOC
2203  Adjust by program base.
2204COMMENT
2205
2206ENUM
2207  BFD_RELOC_386_GOT32
2208ENUMX
2209  BFD_RELOC_386_PLT32
2210ENUMX
2211  BFD_RELOC_386_COPY
2212ENUMX
2213  BFD_RELOC_386_GLOB_DAT
2214ENUMX
2215  BFD_RELOC_386_JUMP_SLOT
2216ENUMX
2217  BFD_RELOC_386_RELATIVE
2218ENUMX
2219  BFD_RELOC_386_GOTOFF
2220ENUMX
2221  BFD_RELOC_386_GOTPC
2222ENUMX
2223  BFD_RELOC_386_TLS_TPOFF
2224ENUMX
2225  BFD_RELOC_386_TLS_IE
2226ENUMX
2227  BFD_RELOC_386_TLS_GOTIE
2228ENUMX
2229  BFD_RELOC_386_TLS_LE
2230ENUMX
2231  BFD_RELOC_386_TLS_GD
2232ENUMX
2233  BFD_RELOC_386_TLS_LDM
2234ENUMX
2235  BFD_RELOC_386_TLS_LDO_32
2236ENUMX
2237  BFD_RELOC_386_TLS_IE_32
2238ENUMX
2239  BFD_RELOC_386_TLS_LE_32
2240ENUMX
2241  BFD_RELOC_386_TLS_DTPMOD32
2242ENUMX
2243  BFD_RELOC_386_TLS_DTPOFF32
2244ENUMX
2245  BFD_RELOC_386_TLS_TPOFF32
2246ENUMDOC
2247  i386/elf relocations
2248
2249ENUM
2250  BFD_RELOC_X86_64_GOT32
2251ENUMX
2252  BFD_RELOC_X86_64_PLT32
2253ENUMX
2254  BFD_RELOC_X86_64_COPY
2255ENUMX
2256  BFD_RELOC_X86_64_GLOB_DAT
2257ENUMX
2258  BFD_RELOC_X86_64_JUMP_SLOT
2259ENUMX
2260  BFD_RELOC_X86_64_RELATIVE
2261ENUMX
2262  BFD_RELOC_X86_64_GOTPCREL
2263ENUMX
2264  BFD_RELOC_X86_64_32S
2265ENUMX
2266  BFD_RELOC_X86_64_DTPMOD64
2267ENUMX
2268  BFD_RELOC_X86_64_DTPOFF64
2269ENUMX
2270  BFD_RELOC_X86_64_TPOFF64
2271ENUMX
2272  BFD_RELOC_X86_64_TLSGD
2273ENUMX
2274  BFD_RELOC_X86_64_TLSLD
2275ENUMX
2276  BFD_RELOC_X86_64_DTPOFF32
2277ENUMX
2278  BFD_RELOC_X86_64_GOTTPOFF
2279ENUMX
2280  BFD_RELOC_X86_64_TPOFF32
2281ENUMDOC
2282  x86-64/elf relocations
2283
2284ENUM
2285  BFD_RELOC_NS32K_IMM_8
2286ENUMX
2287  BFD_RELOC_NS32K_IMM_16
2288ENUMX
2289  BFD_RELOC_NS32K_IMM_32
2290ENUMX
2291  BFD_RELOC_NS32K_IMM_8_PCREL
2292ENUMX
2293  BFD_RELOC_NS32K_IMM_16_PCREL
2294ENUMX
2295  BFD_RELOC_NS32K_IMM_32_PCREL
2296ENUMX
2297  BFD_RELOC_NS32K_DISP_8
2298ENUMX
2299  BFD_RELOC_NS32K_DISP_16
2300ENUMX
2301  BFD_RELOC_NS32K_DISP_32
2302ENUMX
2303  BFD_RELOC_NS32K_DISP_8_PCREL
2304ENUMX
2305  BFD_RELOC_NS32K_DISP_16_PCREL
2306ENUMX
2307  BFD_RELOC_NS32K_DISP_32_PCREL
2308ENUMDOC
2309  ns32k relocations
2310
2311ENUM
2312  BFD_RELOC_PDP11_DISP_8_PCREL
2313ENUMX
2314  BFD_RELOC_PDP11_DISP_6_PCREL
2315ENUMDOC
2316  PDP11 relocations
2317
2318ENUM
2319  BFD_RELOC_PJ_CODE_HI16
2320ENUMX
2321  BFD_RELOC_PJ_CODE_LO16
2322ENUMX
2323  BFD_RELOC_PJ_CODE_DIR16
2324ENUMX
2325  BFD_RELOC_PJ_CODE_DIR32
2326ENUMX
2327  BFD_RELOC_PJ_CODE_REL16
2328ENUMX
2329  BFD_RELOC_PJ_CODE_REL32
2330ENUMDOC
2331  Picojava relocs.  Not all of these appear in object files.
2332
2333ENUM
2334  BFD_RELOC_PPC_B26
2335ENUMX
2336  BFD_RELOC_PPC_BA26
2337ENUMX
2338  BFD_RELOC_PPC_TOC16
2339ENUMX
2340  BFD_RELOC_PPC_B16
2341ENUMX
2342  BFD_RELOC_PPC_B16_BRTAKEN
2343ENUMX
2344  BFD_RELOC_PPC_B16_BRNTAKEN
2345ENUMX
2346  BFD_RELOC_PPC_BA16
2347ENUMX
2348  BFD_RELOC_PPC_BA16_BRTAKEN
2349ENUMX
2350  BFD_RELOC_PPC_BA16_BRNTAKEN
2351ENUMX
2352  BFD_RELOC_PPC_COPY
2353ENUMX
2354  BFD_RELOC_PPC_GLOB_DAT
2355ENUMX
2356  BFD_RELOC_PPC_JMP_SLOT
2357ENUMX
2358  BFD_RELOC_PPC_RELATIVE
2359ENUMX
2360  BFD_RELOC_PPC_LOCAL24PC
2361ENUMX
2362  BFD_RELOC_PPC_EMB_NADDR32
2363ENUMX
2364  BFD_RELOC_PPC_EMB_NADDR16
2365ENUMX
2366  BFD_RELOC_PPC_EMB_NADDR16_LO
2367ENUMX
2368  BFD_RELOC_PPC_EMB_NADDR16_HI
2369ENUMX
2370  BFD_RELOC_PPC_EMB_NADDR16_HA
2371ENUMX
2372  BFD_RELOC_PPC_EMB_SDAI16
2373ENUMX
2374  BFD_RELOC_PPC_EMB_SDA2I16
2375ENUMX
2376  BFD_RELOC_PPC_EMB_SDA2REL
2377ENUMX
2378  BFD_RELOC_PPC_EMB_SDA21
2379ENUMX
2380  BFD_RELOC_PPC_EMB_MRKREF
2381ENUMX
2382  BFD_RELOC_PPC_EMB_RELSEC16
2383ENUMX
2384  BFD_RELOC_PPC_EMB_RELST_LO
2385ENUMX
2386  BFD_RELOC_PPC_EMB_RELST_HI
2387ENUMX
2388  BFD_RELOC_PPC_EMB_RELST_HA
2389ENUMX
2390  BFD_RELOC_PPC_EMB_BIT_FLD
2391ENUMX
2392  BFD_RELOC_PPC_EMB_RELSDA
2393ENUMX
2394  BFD_RELOC_PPC64_HIGHER
2395ENUMX
2396  BFD_RELOC_PPC64_HIGHER_S
2397ENUMX
2398  BFD_RELOC_PPC64_HIGHEST
2399ENUMX
2400  BFD_RELOC_PPC64_HIGHEST_S
2401ENUMX
2402  BFD_RELOC_PPC64_TOC16_LO
2403ENUMX
2404  BFD_RELOC_PPC64_TOC16_HI
2405ENUMX
2406  BFD_RELOC_PPC64_TOC16_HA
2407ENUMX
2408  BFD_RELOC_PPC64_TOC
2409ENUMX
2410  BFD_RELOC_PPC64_PLTGOT16
2411ENUMX
2412  BFD_RELOC_PPC64_PLTGOT16_LO
2413ENUMX
2414  BFD_RELOC_PPC64_PLTGOT16_HI
2415ENUMX
2416  BFD_RELOC_PPC64_PLTGOT16_HA
2417ENUMX
2418  BFD_RELOC_PPC64_ADDR16_DS
2419ENUMX
2420  BFD_RELOC_PPC64_ADDR16_LO_DS
2421ENUMX
2422  BFD_RELOC_PPC64_GOT16_DS
2423ENUMX
2424  BFD_RELOC_PPC64_GOT16_LO_DS
2425ENUMX
2426  BFD_RELOC_PPC64_PLT16_LO_DS
2427ENUMX
2428  BFD_RELOC_PPC64_SECTOFF_DS
2429ENUMX
2430  BFD_RELOC_PPC64_SECTOFF_LO_DS
2431ENUMX
2432  BFD_RELOC_PPC64_TOC16_DS
2433ENUMX
2434  BFD_RELOC_PPC64_TOC16_LO_DS
2435ENUMX
2436  BFD_RELOC_PPC64_PLTGOT16_DS
2437ENUMX
2438  BFD_RELOC_PPC64_PLTGOT16_LO_DS
2439ENUMDOC
2440  Power(rs6000) and PowerPC relocations.
2441
2442ENUM
2443  BFD_RELOC_PPC_TLS
2444ENUMX
2445  BFD_RELOC_PPC_DTPMOD
2446ENUMX
2447  BFD_RELOC_PPC_TPREL16
2448ENUMX
2449  BFD_RELOC_PPC_TPREL16_LO
2450ENUMX
2451  BFD_RELOC_PPC_TPREL16_HI
2452ENUMX
2453  BFD_RELOC_PPC_TPREL16_HA
2454ENUMX
2455  BFD_RELOC_PPC_TPREL
2456ENUMX
2457  BFD_RELOC_PPC_DTPREL16
2458ENUMX
2459  BFD_RELOC_PPC_DTPREL16_LO
2460ENUMX
2461  BFD_RELOC_PPC_DTPREL16_HI
2462ENUMX
2463  BFD_RELOC_PPC_DTPREL16_HA
2464ENUMX
2465  BFD_RELOC_PPC_DTPREL
2466ENUMX
2467  BFD_RELOC_PPC_GOT_TLSGD16
2468ENUMX
2469  BFD_RELOC_PPC_GOT_TLSGD16_LO
2470ENUMX
2471  BFD_RELOC_PPC_GOT_TLSGD16_HI
2472ENUMX
2473  BFD_RELOC_PPC_GOT_TLSGD16_HA
2474ENUMX
2475  BFD_RELOC_PPC_GOT_TLSLD16
2476ENUMX
2477  BFD_RELOC_PPC_GOT_TLSLD16_LO
2478ENUMX
2479  BFD_RELOC_PPC_GOT_TLSLD16_HI
2480ENUMX
2481  BFD_RELOC_PPC_GOT_TLSLD16_HA
2482ENUMX
2483  BFD_RELOC_PPC_GOT_TPREL16
2484ENUMX
2485  BFD_RELOC_PPC_GOT_TPREL16_LO
2486ENUMX
2487  BFD_RELOC_PPC_GOT_TPREL16_HI
2488ENUMX
2489  BFD_RELOC_PPC_GOT_TPREL16_HA
2490ENUMX
2491  BFD_RELOC_PPC_GOT_DTPREL16
2492ENUMX
2493  BFD_RELOC_PPC_GOT_DTPREL16_LO
2494ENUMX
2495  BFD_RELOC_PPC_GOT_DTPREL16_HI
2496ENUMX
2497  BFD_RELOC_PPC_GOT_DTPREL16_HA
2498ENUMX
2499  BFD_RELOC_PPC64_TPREL16_DS
2500ENUMX
2501  BFD_RELOC_PPC64_TPREL16_LO_DS
2502ENUMX
2503  BFD_RELOC_PPC64_TPREL16_HIGHER
2504ENUMX
2505  BFD_RELOC_PPC64_TPREL16_HIGHERA
2506ENUMX
2507  BFD_RELOC_PPC64_TPREL16_HIGHEST
2508ENUMX
2509  BFD_RELOC_PPC64_TPREL16_HIGHESTA
2510ENUMX
2511  BFD_RELOC_PPC64_DTPREL16_DS
2512ENUMX
2513  BFD_RELOC_PPC64_DTPREL16_LO_DS
2514ENUMX
2515  BFD_RELOC_PPC64_DTPREL16_HIGHER
2516ENUMX
2517  BFD_RELOC_PPC64_DTPREL16_HIGHERA
2518ENUMX
2519  BFD_RELOC_PPC64_DTPREL16_HIGHEST
2520ENUMX
2521  BFD_RELOC_PPC64_DTPREL16_HIGHESTA
2522ENUMDOC
2523  PowerPC and PowerPC64 thread-local storage relocations.
2524
2525ENUM
2526  BFD_RELOC_I370_D12
2527ENUMDOC
2528  IBM 370/390 relocations
2529
2530ENUM
2531  BFD_RELOC_CTOR
2532ENUMDOC
2533  The type of reloc used to build a constructor table - at the moment
2534  probably a 32 bit wide absolute relocation, but the target can choose.
2535  It generally does map to one of the other relocation types.
2536
2537ENUM
2538  BFD_RELOC_ARM_PCREL_BRANCH
2539ENUMDOC
2540  ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
2541  not stored in the instruction.
2542ENUM
2543  BFD_RELOC_ARM_PCREL_BLX
2544ENUMDOC
2545  ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
2546  not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2547  field in the instruction.
2548ENUM
2549  BFD_RELOC_THUMB_PCREL_BLX
2550ENUMDOC
2551  Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
2552  not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
2553  field in the instruction.
2554ENUM
2555  BFD_RELOC_ARM_IMMEDIATE
2556ENUMX
2557  BFD_RELOC_ARM_ADRL_IMMEDIATE
2558ENUMX
2559  BFD_RELOC_ARM_OFFSET_IMM
2560ENUMX
2561  BFD_RELOC_ARM_SHIFT_IMM
2562ENUMX
2563  BFD_RELOC_ARM_SMI
2564ENUMX
2565  BFD_RELOC_ARM_SWI
2566ENUMX
2567  BFD_RELOC_ARM_MULTI
2568ENUMX
2569  BFD_RELOC_ARM_CP_OFF_IMM
2570ENUMX
2571  BFD_RELOC_ARM_CP_OFF_IMM_S2
2572ENUMX
2573  BFD_RELOC_ARM_ADR_IMM
2574ENUMX
2575  BFD_RELOC_ARM_LDR_IMM
2576ENUMX
2577  BFD_RELOC_ARM_LITERAL
2578ENUMX
2579  BFD_RELOC_ARM_IN_POOL
2580ENUMX
2581  BFD_RELOC_ARM_OFFSET_IMM8
2582ENUMX
2583  BFD_RELOC_ARM_HWLITERAL
2584ENUMX
2585  BFD_RELOC_ARM_THUMB_ADD
2586ENUMX
2587  BFD_RELOC_ARM_THUMB_IMM
2588ENUMX
2589  BFD_RELOC_ARM_THUMB_SHIFT
2590ENUMX
2591  BFD_RELOC_ARM_THUMB_OFFSET
2592ENUMX
2593  BFD_RELOC_ARM_GOT12
2594ENUMX
2595  BFD_RELOC_ARM_GOT32
2596ENUMX
2597  BFD_RELOC_ARM_JUMP_SLOT
2598ENUMX
2599  BFD_RELOC_ARM_COPY
2600ENUMX
2601  BFD_RELOC_ARM_GLOB_DAT
2602ENUMX
2603  BFD_RELOC_ARM_PLT32
2604ENUMX
2605  BFD_RELOC_ARM_RELATIVE
2606ENUMX
2607  BFD_RELOC_ARM_GOTOFF
2608ENUMX
2609  BFD_RELOC_ARM_GOTPC
2610ENUMDOC
2611  These relocs are only used within the ARM assembler.  They are not
2612  (at present) written to any object files.
2613ENUM
2614  BFD_RELOC_ARM_TARGET1
2615ENUMDOC
2616  Pc-relative or absolute relocation depending on target.  Used for
2617  entries in .init_array sections.
2618ENUM
2619  BFD_RELOC_ARM_ROSEGREL32
2620ENUMDOC
2621  Read-only segment base relative address.
2622ENUM
2623  BFD_RELOC_ARM_SBREL32
2624ENUMDOC
2625  Data segment base relative address.
2626ENUM
2627  BFD_RELOC_ARM_TARGET2
2628ENUMDOC
2629  This reloc is used for References to RTTI dta from exception handling
2630  tables.  The actual definition depends on the target.  It may be a
2631  pc-relative or some form of GOT-indirect relocation.
2632ENUM
2633  BFD_RELOC_ARM_PREL31
2634ENUMDOC
2635  31-bit PC relative address.
2636
2637ENUM
2638  BFD_RELOC_SH_PCDISP8BY2
2639ENUMX
2640  BFD_RELOC_SH_PCDISP12BY2
2641ENUMX
2642  BFD_RELOC_SH_IMM3
2643ENUMX
2644  BFD_RELOC_SH_IMM3U
2645ENUMX
2646  BFD_RELOC_SH_DISP12
2647ENUMX
2648  BFD_RELOC_SH_DISP12BY2
2649ENUMX
2650  BFD_RELOC_SH_DISP12BY4
2651ENUMX
2652  BFD_RELOC_SH_DISP12BY8
2653ENUMX
2654  BFD_RELOC_SH_DISP20
2655ENUMX
2656  BFD_RELOC_SH_DISP20BY8
2657ENUMX
2658  BFD_RELOC_SH_IMM4
2659ENUMX
2660  BFD_RELOC_SH_IMM4BY2
2661ENUMX
2662  BFD_RELOC_SH_IMM4BY4
2663ENUMX
2664  BFD_RELOC_SH_IMM8
2665ENUMX
2666  BFD_RELOC_SH_IMM8BY2
2667ENUMX
2668  BFD_RELOC_SH_IMM8BY4
2669ENUMX
2670  BFD_RELOC_SH_PCRELIMM8BY2
2671ENUMX
2672  BFD_RELOC_SH_PCRELIMM8BY4
2673ENUMX
2674  BFD_RELOC_SH_SWITCH16
2675ENUMX
2676  BFD_RELOC_SH_SWITCH32
2677ENUMX
2678  BFD_RELOC_SH_USES
2679ENUMX
2680  BFD_RELOC_SH_COUNT
2681ENUMX
2682  BFD_RELOC_SH_ALIGN
2683ENUMX
2684  BFD_RELOC_SH_CODE
2685ENUMX
2686  BFD_RELOC_SH_DATA
2687ENUMX
2688  BFD_RELOC_SH_LABEL
2689ENUMX
2690  BFD_RELOC_SH_LOOP_START
2691ENUMX
2692  BFD_RELOC_SH_LOOP_END
2693ENUMX
2694  BFD_RELOC_SH_COPY
2695ENUMX
2696  BFD_RELOC_SH_GLOB_DAT
2697ENUMX
2698  BFD_RELOC_SH_JMP_SLOT
2699ENUMX
2700  BFD_RELOC_SH_RELATIVE
2701ENUMX
2702  BFD_RELOC_SH_GOTPC
2703ENUMX
2704  BFD_RELOC_SH_GOT_LOW16
2705ENUMX
2706  BFD_RELOC_SH_GOT_MEDLOW16
2707ENUMX
2708  BFD_RELOC_SH_GOT_MEDHI16
2709ENUMX
2710  BFD_RELOC_SH_GOT_HI16
2711ENUMX
2712  BFD_RELOC_SH_GOTPLT_LOW16
2713ENUMX
2714  BFD_RELOC_SH_GOTPLT_MEDLOW16
2715ENUMX
2716  BFD_RELOC_SH_GOTPLT_MEDHI16
2717ENUMX
2718  BFD_RELOC_SH_GOTPLT_HI16
2719ENUMX
2720  BFD_RELOC_SH_PLT_LOW16
2721ENUMX
2722  BFD_RELOC_SH_PLT_MEDLOW16
2723ENUMX
2724  BFD_RELOC_SH_PLT_MEDHI16
2725ENUMX
2726  BFD_RELOC_SH_PLT_HI16
2727ENUMX
2728  BFD_RELOC_SH_GOTOFF_LOW16
2729ENUMX
2730  BFD_RELOC_SH_GOTOFF_MEDLOW16
2731ENUMX
2732  BFD_RELOC_SH_GOTOFF_MEDHI16
2733ENUMX
2734  BFD_RELOC_SH_GOTOFF_HI16
2735ENUMX
2736  BFD_RELOC_SH_GOTPC_LOW16
2737ENUMX
2738  BFD_RELOC_SH_GOTPC_MEDLOW16
2739ENUMX
2740  BFD_RELOC_SH_GOTPC_MEDHI16
2741ENUMX
2742  BFD_RELOC_SH_GOTPC_HI16
2743ENUMX
2744  BFD_RELOC_SH_COPY64
2745ENUMX
2746  BFD_RELOC_SH_GLOB_DAT64
2747ENUMX
2748  BFD_RELOC_SH_JMP_SLOT64
2749ENUMX
2750  BFD_RELOC_SH_RELATIVE64
2751ENUMX
2752  BFD_RELOC_SH_GOT10BY4
2753ENUMX
2754  BFD_RELOC_SH_GOT10BY8
2755ENUMX
2756  BFD_RELOC_SH_GOTPLT10BY4
2757ENUMX
2758  BFD_RELOC_SH_GOTPLT10BY8
2759ENUMX
2760  BFD_RELOC_SH_GOTPLT32
2761ENUMX
2762  BFD_RELOC_SH_SHMEDIA_CODE
2763ENUMX
2764  BFD_RELOC_SH_IMMU5
2765ENUMX
2766  BFD_RELOC_SH_IMMS6
2767ENUMX
2768  BFD_RELOC_SH_IMMS6BY32
2769ENUMX
2770  BFD_RELOC_SH_IMMU6
2771ENUMX
2772  BFD_RELOC_SH_IMMS10
2773ENUMX
2774  BFD_RELOC_SH_IMMS10BY2
2775ENUMX
2776  BFD_RELOC_SH_IMMS10BY4
2777ENUMX
2778  BFD_RELOC_SH_IMMS10BY8
2779ENUMX
2780  BFD_RELOC_SH_IMMS16
2781ENUMX
2782  BFD_RELOC_SH_IMMU16
2783ENUMX
2784  BFD_RELOC_SH_IMM_LOW16
2785ENUMX
2786  BFD_RELOC_SH_IMM_LOW16_PCREL
2787ENUMX
2788  BFD_RELOC_SH_IMM_MEDLOW16
2789ENUMX
2790  BFD_RELOC_SH_IMM_MEDLOW16_PCREL
2791ENUMX
2792  BFD_RELOC_SH_IMM_MEDHI16
2793ENUMX
2794  BFD_RELOC_SH_IMM_MEDHI16_PCREL
2795ENUMX
2796  BFD_RELOC_SH_IMM_HI16
2797ENUMX
2798  BFD_RELOC_SH_IMM_HI16_PCREL
2799ENUMX
2800  BFD_RELOC_SH_PT_16
2801ENUMX
2802  BFD_RELOC_SH_TLS_GD_32
2803ENUMX
2804  BFD_RELOC_SH_TLS_LD_32
2805ENUMX
2806  BFD_RELOC_SH_TLS_LDO_32
2807ENUMX
2808  BFD_RELOC_SH_TLS_IE_32
2809ENUMX
2810  BFD_RELOC_SH_TLS_LE_32
2811ENUMX
2812  BFD_RELOC_SH_TLS_DTPMOD32
2813ENUMX
2814  BFD_RELOC_SH_TLS_DTPOFF32
2815ENUMX
2816  BFD_RELOC_SH_TLS_TPOFF32
2817ENUMDOC
2818  Renesas / SuperH SH relocs.  Not all of these appear in object files.
2819
2820ENUM
2821  BFD_RELOC_THUMB_PCREL_BRANCH9
2822ENUMX
2823  BFD_RELOC_THUMB_PCREL_BRANCH12
2824ENUMX
2825  BFD_RELOC_THUMB_PCREL_BRANCH23
2826ENUMDOC
2827  Thumb 23-, 12- and 9-bit pc-relative branches.  The lowest bit must
2828  be zero and is not stored in the instruction.
2829
2830ENUM
2831  BFD_RELOC_ARC_B22_PCREL
2832ENUMDOC
2833  ARC Cores relocs.
2834  ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
2835  not stored in the instruction.  The high 20 bits are installed in bits 26
2836  through 7 of the instruction.
2837ENUM
2838  BFD_RELOC_ARC_B26
2839ENUMDOC
2840  ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
2841  stored in the instruction.  The high 24 bits are installed in bits 23
2842  through 0.
2843
2844ENUM
2845  BFD_RELOC_D10V_10_PCREL_R
2846ENUMDOC
2847  Mitsubishi D10V relocs.
2848  This is a 10-bit reloc with the right 2 bits
2849  assumed to be 0.
2850ENUM
2851  BFD_RELOC_D10V_10_PCREL_L
2852ENUMDOC
2853  Mitsubishi D10V relocs.
2854  This is a 10-bit reloc with the right 2 bits
2855  assumed to be 0.  This is the same as the previous reloc
2856  except it is in the left container, i.e.,
2857  shifted left 15 bits.
2858ENUM
2859  BFD_RELOC_D10V_18
2860ENUMDOC
2861  This is an 18-bit reloc with the right 2 bits
2862  assumed to be 0.
2863ENUM
2864  BFD_RELOC_D10V_18_PCREL
2865ENUMDOC
2866  This is an 18-bit reloc with the right 2 bits
2867  assumed to be 0.
2868
2869ENUM
2870  BFD_RELOC_D30V_6
2871ENUMDOC
2872  Mitsubishi D30V relocs.
2873  This is a 6-bit absolute reloc.
2874ENUM
2875  BFD_RELOC_D30V_9_PCREL
2876ENUMDOC
2877  This is a 6-bit pc-relative reloc with
2878  the right 3 bits assumed to be 0.
2879ENUM
2880  BFD_RELOC_D30V_9_PCREL_R
2881ENUMDOC
2882  This is a 6-bit pc-relative reloc with
2883  the right 3 bits assumed to be 0. Same
2884  as the previous reloc but on the right side
2885  of the container.
2886ENUM
2887  BFD_RELOC_D30V_15
2888ENUMDOC
2889  This is a 12-bit absolute reloc with the
2890  right 3 bitsassumed to be 0.
2891ENUM
2892  BFD_RELOC_D30V_15_PCREL
2893ENUMDOC
2894  This is a 12-bit pc-relative reloc with
2895  the right 3 bits assumed to be 0.
2896ENUM
2897  BFD_RELOC_D30V_15_PCREL_R
2898ENUMDOC
2899  This is a 12-bit pc-relative reloc with
2900  the right 3 bits assumed to be 0. Same
2901  as the previous reloc but on the right side
2902  of the container.
2903ENUM
2904  BFD_RELOC_D30V_21
2905ENUMDOC
2906  This is an 18-bit absolute reloc with
2907  the right 3 bits assumed to be 0.
2908ENUM
2909  BFD_RELOC_D30V_21_PCREL
2910ENUMDOC
2911  This is an 18-bit pc-relative reloc with
2912  the right 3 bits assumed to be 0.
2913ENUM
2914  BFD_RELOC_D30V_21_PCREL_R
2915ENUMDOC
2916  This is an 18-bit pc-relative reloc with
2917  the right 3 bits assumed to be 0. Same
2918  as the previous reloc but on the right side
2919  of the container.
2920ENUM
2921  BFD_RELOC_D30V_32
2922ENUMDOC
2923  This is a 32-bit absolute reloc.
2924ENUM
2925  BFD_RELOC_D30V_32_PCREL
2926ENUMDOC
2927  This is a 32-bit pc-relative reloc.
2928
2929ENUM
2930  BFD_RELOC_DLX_HI16_S
2931ENUMDOC
2932  DLX relocs
2933ENUM
2934  BFD_RELOC_DLX_LO16
2935ENUMDOC
2936  DLX relocs
2937ENUM
2938  BFD_RELOC_DLX_JMP26
2939ENUMDOC
2940  DLX relocs
2941
2942ENUM
2943  BFD_RELOC_M32R_24
2944ENUMDOC
2945  Renesas M32R (formerly Mitsubishi M32R) relocs.
2946  This is a 24 bit absolute address.
2947ENUM
2948  BFD_RELOC_M32R_10_PCREL
2949ENUMDOC
2950  This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.
2951ENUM
2952  BFD_RELOC_M32R_18_PCREL
2953ENUMDOC
2954  This is an 18-bit reloc with the right 2 bits assumed to be 0.
2955ENUM
2956  BFD_RELOC_M32R_26_PCREL
2957ENUMDOC
2958  This is a 26-bit reloc with the right 2 bits assumed to be 0.
2959ENUM
2960  BFD_RELOC_M32R_HI16_ULO
2961ENUMDOC
2962  This is a 16-bit reloc containing the high 16 bits of an address
2963  used when the lower 16 bits are treated as unsigned.
2964ENUM
2965  BFD_RELOC_M32R_HI16_SLO
2966ENUMDOC
2967  This is a 16-bit reloc containing the high 16 bits of an address
2968  used when the lower 16 bits are treated as signed.
2969ENUM
2970  BFD_RELOC_M32R_LO16
2971ENUMDOC
2972  This is a 16-bit reloc containing the lower 16 bits of an address.
2973ENUM
2974  BFD_RELOC_M32R_SDA16
2975ENUMDOC
2976  This is a 16-bit reloc containing the small data area offset for use in
2977  add3, load, and store instructions.
2978ENUM
2979  BFD_RELOC_M32R_GOT24
2980ENUMX
2981  BFD_RELOC_M32R_26_PLTREL
2982ENUMX
2983  BFD_RELOC_M32R_COPY
2984ENUMX
2985  BFD_RELOC_M32R_GLOB_DAT
2986ENUMX
2987  BFD_RELOC_M32R_JMP_SLOT
2988ENUMX
2989  BFD_RELOC_M32R_RELATIVE
2990ENUMX
2991  BFD_RELOC_M32R_GOTOFF
2992ENUMX
2993  BFD_RELOC_M32R_GOTOFF_HI_ULO
2994ENUMX
2995  BFD_RELOC_M32R_GOTOFF_HI_SLO
2996ENUMX
2997  BFD_RELOC_M32R_GOTOFF_LO
2998ENUMX
2999  BFD_RELOC_M32R_GOTPC24
3000ENUMX
3001  BFD_RELOC_M32R_GOT16_HI_ULO
3002ENUMX
3003  BFD_RELOC_M32R_GOT16_HI_SLO
3004ENUMX
3005  BFD_RELOC_M32R_GOT16_LO
3006ENUMX
3007  BFD_RELOC_M32R_GOTPC_HI_ULO
3008ENUMX
3009  BFD_RELOC_M32R_GOTPC_HI_SLO
3010ENUMX
3011  BFD_RELOC_M32R_GOTPC_LO
3012ENUMDOC
3013  For PIC.
3014
3015
3016ENUM
3017  BFD_RELOC_V850_9_PCREL
3018ENUMDOC
3019  This is a 9-bit reloc
3020ENUM
3021  BFD_RELOC_V850_22_PCREL
3022ENUMDOC
3023  This is a 22-bit reloc
3024
3025ENUM
3026  BFD_RELOC_V850_SDA_16_16_OFFSET
3027ENUMDOC
3028  This is a 16 bit offset from the short data area pointer.
3029ENUM
3030  BFD_RELOC_V850_SDA_15_16_OFFSET
3031ENUMDOC
3032  This is a 16 bit offset (of which only 15 bits are used) from the
3033  short data area pointer.
3034ENUM
3035  BFD_RELOC_V850_ZDA_16_16_OFFSET
3036ENUMDOC
3037  This is a 16 bit offset from the zero data area pointer.
3038ENUM
3039  BFD_RELOC_V850_ZDA_15_16_OFFSET
3040ENUMDOC
3041  This is a 16 bit offset (of which only 15 bits are used) from the
3042  zero data area pointer.
3043ENUM
3044  BFD_RELOC_V850_TDA_6_8_OFFSET
3045ENUMDOC
3046  This is an 8 bit offset (of which only 6 bits are used) from the
3047  tiny data area pointer.
3048ENUM
3049  BFD_RELOC_V850_TDA_7_8_OFFSET
3050ENUMDOC
3051  This is an 8bit offset (of which only 7 bits are used) from the tiny
3052  data area pointer.
3053ENUM
3054  BFD_RELOC_V850_TDA_7_7_OFFSET
3055ENUMDOC
3056  This is a 7 bit offset from the tiny data area pointer.
3057ENUM
3058  BFD_RELOC_V850_TDA_16_16_OFFSET
3059ENUMDOC
3060  This is a 16 bit offset from the tiny data area pointer.
3061COMMENT
3062ENUM
3063  BFD_RELOC_V850_TDA_4_5_OFFSET
3064ENUMDOC
3065  This is a 5 bit offset (of which only 4 bits are used) from the tiny
3066  data area pointer.
3067ENUM
3068  BFD_RELOC_V850_TDA_4_4_OFFSET
3069ENUMDOC
3070  This is a 4 bit offset from the tiny data area pointer.
3071ENUM
3072  BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET
3073ENUMDOC
3074  This is a 16 bit offset from the short data area pointer, with the
3075  bits placed non-contiguously in the instruction.
3076ENUM
3077  BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET
3078ENUMDOC
3079  This is a 16 bit offset from the zero data area pointer, with the
3080  bits placed non-contiguously in the instruction.
3081ENUM
3082  BFD_RELOC_V850_CALLT_6_7_OFFSET
3083ENUMDOC
3084  This is a 6 bit offset from the call table base pointer.
3085ENUM
3086  BFD_RELOC_V850_CALLT_16_16_OFFSET
3087ENUMDOC
3088  This is a 16 bit offset from the call table base pointer.
3089ENUM
3090  BFD_RELOC_V850_LONGCALL
3091ENUMDOC
3092  Used for relaxing indirect function calls.
3093ENUM
3094  BFD_RELOC_V850_LONGJUMP
3095ENUMDOC
3096  Used for relaxing indirect jumps.
3097ENUM
3098  BFD_RELOC_V850_ALIGN
3099ENUMDOC
3100  Used to maintain alignment whilst relaxing.
3101ENUM
3102  BFD_RELOC_MN10300_32_PCREL
3103ENUMDOC
3104  This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
3105  instruction.
3106ENUM
3107  BFD_RELOC_MN10300_16_PCREL
3108ENUMDOC
3109  This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
3110  instruction.
3111
3112ENUM
3113  BFD_RELOC_TIC30_LDP
3114ENUMDOC
3115  This is a 8bit DP reloc for the tms320c30, where the most
3116  significant 8 bits of a 24 bit word are placed into the least
3117  significant 8 bits of the opcode.
3118
3119ENUM
3120  BFD_RELOC_TIC54X_PARTLS7
3121ENUMDOC
3122  This is a 7bit reloc for the tms320c54x, where the least
3123  significant 7 bits of a 16 bit word are placed into the least
3124  significant 7 bits of the opcode.
3125
3126ENUM
3127  BFD_RELOC_TIC54X_PARTMS9
3128ENUMDOC
3129  This is a 9bit DP reloc for the tms320c54x, where the most
3130  significant 9 bits of a 16 bit word are placed into the least
3131  significant 9 bits of the opcode.
3132
3133ENUM
3134  BFD_RELOC_TIC54X_23
3135ENUMDOC
3136  This is an extended address 23-bit reloc for the tms320c54x.
3137
3138ENUM
3139  BFD_RELOC_TIC54X_16_OF_23
3140ENUMDOC
3141  This is a 16-bit reloc for the tms320c54x, where the least
3142  significant 16 bits of a 23-bit extended address are placed into
3143  the opcode.
3144
3145ENUM
3146  BFD_RELOC_TIC54X_MS7_OF_23
3147ENUMDOC
3148  This is a reloc for the tms320c54x, where the most
3149  significant 7 bits of a 23-bit extended address are placed into
3150  the opcode.
3151
3152ENUM
3153  BFD_RELOC_FR30_48
3154ENUMDOC
3155  This is a 48 bit reloc for the FR30 that stores 32 bits.
3156ENUM
3157  BFD_RELOC_FR30_20
3158ENUMDOC
3159  This is a 32 bit reloc for the FR30 that stores 20 bits split up into
3160  two sections.
3161ENUM
3162  BFD_RELOC_FR30_6_IN_4
3163ENUMDOC
3164  This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
3165  4 bits.
3166ENUM
3167  BFD_RELOC_FR30_8_IN_8
3168ENUMDOC
3169  This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
3170  into 8 bits.
3171ENUM
3172  BFD_RELOC_FR30_9_IN_8
3173ENUMDOC
3174  This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
3175  into 8 bits.
3176ENUM
3177  BFD_RELOC_FR30_10_IN_8
3178ENUMDOC
3179  This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
3180  into 8 bits.
3181ENUM
3182  BFD_RELOC_FR30_9_PCREL
3183ENUMDOC
3184  This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
3185  short offset into 8 bits.
3186ENUM
3187  BFD_RELOC_FR30_12_PCREL
3188ENUMDOC
3189  This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
3190  short offset into 11 bits.
3191
3192ENUM
3193  BFD_RELOC_MCORE_PCREL_IMM8BY4
3194ENUMX
3195  BFD_RELOC_MCORE_PCREL_IMM11BY2
3196ENUMX
3197  BFD_RELOC_MCORE_PCREL_IMM4BY2
3198ENUMX
3199  BFD_RELOC_MCORE_PCREL_32
3200ENUMX
3201  BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2
3202ENUMX
3203  BFD_RELOC_MCORE_RVA
3204ENUMDOC
3205  Motorola Mcore relocations.
3206
3207ENUM
3208  BFD_RELOC_MMIX_GETA
3209ENUMX
3210  BFD_RELOC_MMIX_GETA_1
3211ENUMX
3212  BFD_RELOC_MMIX_GETA_2
3213ENUMX
3214  BFD_RELOC_MMIX_GETA_3
3215ENUMDOC
3216  These are relocations for the GETA instruction.
3217ENUM
3218  BFD_RELOC_MMIX_CBRANCH
3219ENUMX
3220  BFD_RELOC_MMIX_CBRANCH_J
3221ENUMX
3222  BFD_RELOC_MMIX_CBRANCH_1
3223ENUMX
3224  BFD_RELOC_MMIX_CBRANCH_2
3225ENUMX
3226  BFD_RELOC_MMIX_CBRANCH_3
3227ENUMDOC
3228  These are relocations for a conditional branch instruction.
3229ENUM
3230  BFD_RELOC_MMIX_PUSHJ
3231ENUMX
3232  BFD_RELOC_MMIX_PUSHJ_1
3233ENUMX
3234  BFD_RELOC_MMIX_PUSHJ_2
3235ENUMX
3236  BFD_RELOC_MMIX_PUSHJ_3
3237ENUMX
3238  BFD_RELOC_MMIX_PUSHJ_STUBBABLE
3239ENUMDOC
3240  These are relocations for the PUSHJ instruction.
3241ENUM
3242  BFD_RELOC_MMIX_JMP
3243ENUMX
3244  BFD_RELOC_MMIX_JMP_1
3245ENUMX
3246  BFD_RELOC_MMIX_JMP_2
3247ENUMX
3248  BFD_RELOC_MMIX_JMP_3
3249ENUMDOC
3250  These are relocations for the JMP instruction.
3251ENUM
3252  BFD_RELOC_MMIX_ADDR19
3253ENUMDOC
3254  This is a relocation for a relative address as in a GETA instruction or
3255  a branch.
3256ENUM
3257  BFD_RELOC_MMIX_ADDR27
3258ENUMDOC
3259  This is a relocation for a relative address as in a JMP instruction.
3260ENUM
3261  BFD_RELOC_MMIX_REG_OR_BYTE
3262ENUMDOC
3263  This is a relocation for an instruction field that may be a general
3264  register or a value 0..255.
3265ENUM
3266  BFD_RELOC_MMIX_REG
3267ENUMDOC
3268  This is a relocation for an instruction field that may be a general
3269  register.
3270ENUM
3271  BFD_RELOC_MMIX_BASE_PLUS_OFFSET
3272ENUMDOC
3273  This is a relocation for two instruction fields holding a register and
3274  an offset, the equivalent of the relocation.
3275ENUM
3276  BFD_RELOC_MMIX_LOCAL
3277ENUMDOC
3278  This relocation is an assertion that the expression is not allocated as
3279  a global register.  It does not modify contents.
3280
3281ENUM
3282  BFD_RELOC_AVR_7_PCREL
3283ENUMDOC
3284  This is a 16 bit reloc for the AVR that stores 8 bit pc relative
3285  short offset into 7 bits.
3286ENUM
3287  BFD_RELOC_AVR_13_PCREL
3288ENUMDOC
3289  This is a 16 bit reloc for the AVR that stores 13 bit pc relative
3290  short offset into 12 bits.
3291ENUM
3292  BFD_RELOC_AVR_16_PM
3293ENUMDOC
3294  This is a 16 bit reloc for the AVR that stores 17 bit value (usually
3295  program memory address) into 16 bits.
3296ENUM
3297  BFD_RELOC_AVR_LO8_LDI
3298ENUMDOC
3299  This is a 16 bit reloc for the AVR that stores 8 bit value (usually
3300  data memory address) into 8 bit immediate value of LDI insn.
3301ENUM
3302  BFD_RELOC_AVR_HI8_LDI
3303ENUMDOC
3304  This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
3305  of data memory address) into 8 bit immediate value of LDI insn.
3306ENUM
3307  BFD_RELOC_AVR_HH8_LDI
3308ENUMDOC
3309  This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
3310  of program memory address) into 8 bit immediate value of LDI insn.
3311ENUM
3312  BFD_RELOC_AVR_LO8_LDI_NEG
3313ENUMDOC
3314  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3315  (usually data memory address) into 8 bit immediate value of SUBI insn.
3316ENUM
3317  BFD_RELOC_AVR_HI8_LDI_NEG
3318ENUMDOC
3319  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3320  (high 8 bit of data memory address) into 8 bit immediate value of
3321  SUBI insn.
3322ENUM
3323  BFD_RELOC_AVR_HH8_LDI_NEG
3324ENUMDOC
3325  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3326  (most high 8 bit of program memory address) into 8 bit immediate value
3327  of LDI or SUBI insn.
3328ENUM
3329  BFD_RELOC_AVR_LO8_LDI_PM
3330ENUMDOC
3331  This is a 16 bit reloc for the AVR that stores 8 bit value (usually
3332  command address) into 8 bit immediate value of LDI insn.
3333ENUM
3334  BFD_RELOC_AVR_HI8_LDI_PM
3335ENUMDOC
3336  This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
3337  of command address) into 8 bit immediate value of LDI insn.
3338ENUM
3339  BFD_RELOC_AVR_HH8_LDI_PM
3340ENUMDOC
3341  This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
3342  of command address) into 8 bit immediate value of LDI insn.
3343ENUM
3344  BFD_RELOC_AVR_LO8_LDI_PM_NEG
3345ENUMDOC
3346  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3347  (usually command address) into 8 bit immediate value of SUBI insn.
3348ENUM
3349  BFD_RELOC_AVR_HI8_LDI_PM_NEG
3350ENUMDOC
3351  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3352  (high 8 bit of 16 bit command address) into 8 bit immediate value
3353  of SUBI insn.
3354ENUM
3355  BFD_RELOC_AVR_HH8_LDI_PM_NEG
3356ENUMDOC
3357  This is a 16 bit reloc for the AVR that stores negated 8 bit value
3358  (high 6 bit of 22 bit command address) into 8 bit immediate
3359  value of SUBI insn.
3360ENUM
3361  BFD_RELOC_AVR_CALL
3362ENUMDOC
3363  This is a 32 bit reloc for the AVR that stores 23 bit value
3364  into 22 bits.
3365
3366ENUM
3367  BFD_RELOC_390_12
3368ENUMDOC
3369   Direct 12 bit.
3370ENUM
3371  BFD_RELOC_390_GOT12
3372ENUMDOC
3373  12 bit GOT offset.
3374ENUM
3375  BFD_RELOC_390_PLT32
3376ENUMDOC
3377  32 bit PC relative PLT address.
3378ENUM
3379  BFD_RELOC_390_COPY
3380ENUMDOC
3381  Copy symbol at runtime.
3382ENUM
3383  BFD_RELOC_390_GLOB_DAT
3384ENUMDOC
3385  Create GOT entry.
3386ENUM
3387  BFD_RELOC_390_JMP_SLOT
3388ENUMDOC
3389  Create PLT entry.
3390ENUM
3391  BFD_RELOC_390_RELATIVE
3392ENUMDOC
3393  Adjust by program base.
3394ENUM
3395  BFD_RELOC_390_GOTPC
3396ENUMDOC
3397  32 bit PC relative offset to GOT.
3398ENUM
3399  BFD_RELOC_390_GOT16
3400ENUMDOC
3401  16 bit GOT offset.
3402ENUM
3403  BFD_RELOC_390_PC16DBL
3404ENUMDOC
3405  PC relative 16 bit shifted by 1.
3406ENUM
3407  BFD_RELOC_390_PLT16DBL
3408ENUMDOC
3409  16 bit PC rel. PLT shifted by 1.
3410ENUM
3411  BFD_RELOC_390_PC32DBL
3412ENUMDOC
3413  PC relative 32 bit shifted by 1.
3414ENUM
3415  BFD_RELOC_390_PLT32DBL
3416ENUMDOC
3417  32 bit PC rel. PLT shifted by 1.
3418ENUM
3419  BFD_RELOC_390_GOTPCDBL
3420ENUMDOC
3421  32 bit PC rel. GOT shifted by 1.
3422ENUM
3423  BFD_RELOC_390_GOT64
3424ENUMDOC
3425  64 bit GOT offset.
3426ENUM
3427  BFD_RELOC_390_PLT64
3428ENUMDOC
3429  64 bit PC relative PLT address.
3430ENUM
3431  BFD_RELOC_390_GOTENT
3432ENUMDOC
3433  32 bit rel. offset to GOT entry.
3434ENUM
3435  BFD_RELOC_390_GOTOFF64
3436ENUMDOC
3437  64 bit offset to GOT.
3438ENUM
3439  BFD_RELOC_390_GOTPLT12
3440ENUMDOC
3441  12-bit offset to symbol-entry within GOT, with PLT handling.
3442ENUM
3443  BFD_RELOC_390_GOTPLT16
3444ENUMDOC
3445  16-bit offset to symbol-entry within GOT, with PLT handling.
3446ENUM
3447  BFD_RELOC_390_GOTPLT32
3448ENUMDOC
3449  32-bit offset to symbol-entry within GOT, with PLT handling.
3450ENUM
3451  BFD_RELOC_390_GOTPLT64
3452ENUMDOC
3453  64-bit offset to symbol-entry within GOT, with PLT handling.
3454ENUM
3455  BFD_RELOC_390_GOTPLTENT
3456ENUMDOC
3457  32-bit rel. offset to symbol-entry within GOT, with PLT handling.
3458ENUM
3459  BFD_RELOC_390_PLTOFF16
3460ENUMDOC
3461  16-bit rel. offset from the GOT to a PLT entry.
3462ENUM
3463  BFD_RELOC_390_PLTOFF32
3464ENUMDOC
3465  32-bit rel. offset from the GOT to a PLT entry.
3466ENUM
3467  BFD_RELOC_390_PLTOFF64
3468ENUMDOC
3469  64-bit rel. offset from the GOT to a PLT entry.
3470
3471ENUM
3472  BFD_RELOC_390_TLS_LOAD
3473ENUMX
3474  BFD_RELOC_390_TLS_GDCALL
3475ENUMX
3476  BFD_RELOC_390_TLS_LDCALL
3477ENUMX
3478  BFD_RELOC_390_TLS_GD32
3479ENUMX
3480  BFD_RELOC_390_TLS_GD64
3481ENUMX
3482  BFD_RELOC_390_TLS_GOTIE12
3483ENUMX
3484  BFD_RELOC_390_TLS_GOTIE32
3485ENUMX
3486  BFD_RELOC_390_TLS_GOTIE64
3487ENUMX
3488  BFD_RELOC_390_TLS_LDM32
3489ENUMX
3490  BFD_RELOC_390_TLS_LDM64
3491ENUMX
3492  BFD_RELOC_390_TLS_IE32
3493ENUMX
3494  BFD_RELOC_390_TLS_IE64
3495ENUMX
3496  BFD_RELOC_390_TLS_IEENT
3497ENUMX
3498  BFD_RELOC_390_TLS_LE32
3499ENUMX
3500  BFD_RELOC_390_TLS_LE64
3501ENUMX
3502  BFD_RELOC_390_TLS_LDO32
3503ENUMX
3504  BFD_RELOC_390_TLS_LDO64
3505ENUMX
3506  BFD_RELOC_390_TLS_DTPMOD
3507ENUMX
3508  BFD_RELOC_390_TLS_DTPOFF
3509ENUMX
3510  BFD_RELOC_390_TLS_TPOFF
3511ENUMDOC
3512  s390 tls relocations.
3513
3514ENUM
3515  BFD_RELOC_390_20
3516ENUMX
3517  BFD_RELOC_390_GOT20
3518ENUMX
3519  BFD_RELOC_390_GOTPLT20
3520ENUMX
3521  BFD_RELOC_390_TLS_GOTIE20
3522ENUMDOC
3523  Long displacement extension.
3524
3525ENUM
3526  BFD_RELOC_IP2K_FR9
3527ENUMDOC
3528  Scenix IP2K - 9-bit register number / data address
3529ENUM
3530  BFD_RELOC_IP2K_BANK
3531ENUMDOC
3532  Scenix IP2K - 4-bit register/data bank number
3533ENUM
3534  BFD_RELOC_IP2K_ADDR16CJP
3535ENUMDOC
3536  Scenix IP2K - low 13 bits of instruction word address
3537ENUM
3538  BFD_RELOC_IP2K_PAGE3
3539ENUMDOC
3540  Scenix IP2K - high 3 bits of instruction word address
3541ENUM
3542  BFD_RELOC_IP2K_LO8DATA
3543ENUMX
3544  BFD_RELOC_IP2K_HI8DATA
3545ENUMX
3546  BFD_RELOC_IP2K_EX8DATA
3547ENUMDOC
3548  Scenix IP2K - ext/low/high 8 bits of data address
3549ENUM
3550  BFD_RELOC_IP2K_LO8INSN
3551ENUMX
3552  BFD_RELOC_IP2K_HI8INSN
3553ENUMDOC
3554  Scenix IP2K - low/high 8 bits of instruction word address
3555ENUM
3556  BFD_RELOC_IP2K_PC_SKIP
3557ENUMDOC
3558  Scenix IP2K - even/odd PC modifier to modify snb pcl.0
3559ENUM
3560  BFD_RELOC_IP2K_TEXT
3561ENUMDOC
3562  Scenix IP2K - 16 bit word address in text section.
3563ENUM
3564  BFD_RELOC_IP2K_FR_OFFSET
3565ENUMDOC
3566  Scenix IP2K - 7-bit sp or dp offset
3567ENUM
3568  BFD_RELOC_VPE4KMATH_DATA
3569ENUMX
3570  BFD_RELOC_VPE4KMATH_INSN
3571ENUMDOC
3572  Scenix VPE4K coprocessor - data/insn-space addressing
3573
3574ENUM
3575  BFD_RELOC_VTABLE_INHERIT
3576ENUMX
3577  BFD_RELOC_VTABLE_ENTRY
3578ENUMDOC
3579  These two relocations are used by the linker to determine which of
3580  the entries in a C++ virtual function table are actually used.  When
3581  the --gc-sections option is given, the linker will zero out the entries
3582  that are not used, so that the code for those functions need not be
3583  included in the output.
3584
3585  VTABLE_INHERIT is a zero-space relocation used to describe to the
3586  linker the inheritance tree of a C++ virtual function table.  The
3587  relocation's symbol should be the parent class' vtable, and the
3588  relocation should be located at the child vtable.
3589
3590  VTABLE_ENTRY is a zero-space relocation that describes the use of a
3591  virtual function table entry.  The reloc's symbol should refer to the
3592  table of the class mentioned in the code.  Off of that base, an offset
3593  describes the entry that is being used.  For Rela hosts, this offset
3594  is stored in the reloc's addend.  For Rel hosts, we are forced to put
3595  this offset in the reloc's section offset.
3596
3597ENUM
3598  BFD_RELOC_IA64_IMM14
3599ENUMX
3600  BFD_RELOC_IA64_IMM22
3601ENUMX
3602  BFD_RELOC_IA64_IMM64
3603ENUMX
3604  BFD_RELOC_IA64_DIR32MSB
3605ENUMX
3606  BFD_RELOC_IA64_DIR32LSB
3607ENUMX
3608  BFD_RELOC_IA64_DIR64MSB
3609ENUMX
3610  BFD_RELOC_IA64_DIR64LSB
3611ENUMX
3612  BFD_RELOC_IA64_GPREL22
3613ENUMX
3614  BFD_RELOC_IA64_GPREL64I
3615ENUMX
3616  BFD_RELOC_IA64_GPREL32MSB
3617ENUMX
3618  BFD_RELOC_IA64_GPREL32LSB
3619ENUMX
3620  BFD_RELOC_IA64_GPREL64MSB
3621ENUMX
3622  BFD_RELOC_IA64_GPREL64LSB
3623ENUMX
3624  BFD_RELOC_IA64_LTOFF22
3625ENUMX
3626  BFD_RELOC_IA64_LTOFF64I
3627ENUMX
3628  BFD_RELOC_IA64_PLTOFF22
3629ENUMX
3630  BFD_RELOC_IA64_PLTOFF64I
3631ENUMX
3632  BFD_RELOC_IA64_PLTOFF64MSB
3633ENUMX
3634  BFD_RELOC_IA64_PLTOFF64LSB
3635ENUMX
3636  BFD_RELOC_IA64_FPTR64I
3637ENUMX
3638  BFD_RELOC_IA64_FPTR32MSB
3639ENUMX
3640  BFD_RELOC_IA64_FPTR32LSB
3641ENUMX
3642  BFD_RELOC_IA64_FPTR64MSB
3643ENUMX
3644  BFD_RELOC_IA64_FPTR64LSB
3645ENUMX
3646  BFD_RELOC_IA64_PCREL21B
3647ENUMX
3648  BFD_RELOC_IA64_PCREL21BI
3649ENUMX
3650  BFD_RELOC_IA64_PCREL21M
3651ENUMX
3652  BFD_RELOC_IA64_PCREL21F
3653ENUMX
3654  BFD_RELOC_IA64_PCREL22
3655ENUMX
3656  BFD_RELOC_IA64_PCREL60B
3657ENUMX
3658  BFD_RELOC_IA64_PCREL64I
3659ENUMX
3660  BFD_RELOC_IA64_PCREL32MSB
3661ENUMX
3662  BFD_RELOC_IA64_PCREL32LSB
3663ENUMX
3664  BFD_RELOC_IA64_PCREL64MSB
3665ENUMX
3666  BFD_RELOC_IA64_PCREL64LSB
3667ENUMX
3668  BFD_RELOC_IA64_LTOFF_FPTR22
3669ENUMX
3670  BFD_RELOC_IA64_LTOFF_FPTR64I
3671ENUMX
3672  BFD_RELOC_IA64_LTOFF_FPTR32MSB
3673ENUMX
3674  BFD_RELOC_IA64_LTOFF_FPTR32LSB
3675ENUMX
3676  BFD_RELOC_IA64_LTOFF_FPTR64MSB
3677ENUMX
3678  BFD_RELOC_IA64_LTOFF_FPTR64LSB
3679ENUMX
3680  BFD_RELOC_IA64_SEGREL32MSB
3681ENUMX
3682  BFD_RELOC_IA64_SEGREL32LSB
3683ENUMX
3684  BFD_RELOC_IA64_SEGREL64MSB
3685ENUMX
3686  BFD_RELOC_IA64_SEGREL64LSB
3687ENUMX
3688  BFD_RELOC_IA64_SECREL32MSB
3689ENUMX
3690  BFD_RELOC_IA64_SECREL32LSB
3691ENUMX
3692  BFD_RELOC_IA64_SECREL64MSB
3693ENUMX
3694  BFD_RELOC_IA64_SECREL64LSB
3695ENUMX
3696  BFD_RELOC_IA64_REL32MSB
3697ENUMX
3698  BFD_RELOC_IA64_REL32LSB
3699ENUMX
3700  BFD_RELOC_IA64_REL64MSB
3701ENUMX
3702  BFD_RELOC_IA64_REL64LSB
3703ENUMX
3704  BFD_RELOC_IA64_LTV32MSB
3705ENUMX
3706  BFD_RELOC_IA64_LTV32LSB
3707ENUMX
3708  BFD_RELOC_IA64_LTV64MSB
3709ENUMX
3710  BFD_RELOC_IA64_LTV64LSB
3711ENUMX
3712  BFD_RELOC_IA64_IPLTMSB
3713ENUMX
3714  BFD_RELOC_IA64_IPLTLSB
3715ENUMX
3716  BFD_RELOC_IA64_COPY
3717ENUMX
3718  BFD_RELOC_IA64_LTOFF22X
3719ENUMX
3720  BFD_RELOC_IA64_LDXMOV
3721ENUMX
3722  BFD_RELOC_IA64_TPREL14
3723ENUMX
3724  BFD_RELOC_IA64_TPREL22
3725ENUMX
3726  BFD_RELOC_IA64_TPREL64I
3727ENUMX
3728  BFD_RELOC_IA64_TPREL64MSB
3729ENUMX
3730  BFD_RELOC_IA64_TPREL64LSB
3731ENUMX
3732  BFD_RELOC_IA64_LTOFF_TPREL22
3733ENUMX
3734  BFD_RELOC_IA64_DTPMOD64MSB
3735ENUMX
3736  BFD_RELOC_IA64_DTPMOD64LSB
3737ENUMX
3738  BFD_RELOC_IA64_LTOFF_DTPMOD22
3739ENUMX
3740  BFD_RELOC_IA64_DTPREL14
3741ENUMX
3742  BFD_RELOC_IA64_DTPREL22
3743ENUMX
3744  BFD_RELOC_IA64_DTPREL64I
3745ENUMX
3746  BFD_RELOC_IA64_DTPREL32MSB
3747ENUMX
3748  BFD_RELOC_IA64_DTPREL32LSB
3749ENUMX
3750  BFD_RELOC_IA64_DTPREL64MSB
3751ENUMX
3752  BFD_RELOC_IA64_DTPREL64LSB
3753ENUMX
3754  BFD_RELOC_IA64_LTOFF_DTPREL22
3755ENUMDOC
3756  Intel IA64 Relocations.
3757
3758ENUM
3759  BFD_RELOC_M68HC11_HI8
3760ENUMDOC
3761  Motorola 68HC11 reloc.
3762  This is the 8 bit high part of an absolute address.
3763ENUM
3764  BFD_RELOC_M68HC11_LO8
3765ENUMDOC
3766  Motorola 68HC11 reloc.
3767  This is the 8 bit low part of an absolute address.
3768ENUM
3769  BFD_RELOC_M68HC11_3B
3770ENUMDOC
3771  Motorola 68HC11 reloc.
3772  This is the 3 bit of a value.
3773ENUM
3774  BFD_RELOC_M68HC11_RL_JUMP
3775ENUMDOC
3776  Motorola 68HC11 reloc.
3777  This reloc marks the beginning of a jump/call instruction.
3778  It is used for linker relaxation to correctly identify beginning
3779  of instruction and change some branches to use PC-relative
3780  addressing mode.
3781ENUM
3782  BFD_RELOC_M68HC11_RL_GROUP
3783ENUMDOC
3784  Motorola 68HC11 reloc.
3785  This reloc marks a group of several instructions that gcc generates
3786  and for which the linker relaxation pass can modify and/or remove
3787  some of them.
3788ENUM
3789  BFD_RELOC_M68HC11_LO16
3790ENUMDOC
3791  Motorola 68HC11 reloc.
3792  This is the 16-bit lower part of an address.  It is used for 'call'
3793  instruction to specify the symbol address without any special
3794  transformation (due to memory bank window).
3795ENUM
3796  BFD_RELOC_M68HC11_PAGE
3797ENUMDOC
3798  Motorola 68HC11 reloc.
3799  This is a 8-bit reloc that specifies the page number of an address.
3800  It is used by 'call' instruction to specify the page number of
3801  the symbol.
3802ENUM
3803  BFD_RELOC_M68HC11_24
3804ENUMDOC
3805  Motorola 68HC11 reloc.
3806  This is a 24-bit reloc that represents the address with a 16-bit
3807  value and a 8-bit page number.  The symbol address is transformed
3808  to follow the 16K memory bank of 68HC12 (seen as mapped in the window).
3809ENUM
3810  BFD_RELOC_M68HC12_5B
3811ENUMDOC
3812  Motorola 68HC12 reloc.
3813  This is the 5 bits of a value.
3814
3815ENUM
3816  BFD_RELOC_16C_NUM08
3817ENUMX
3818  BFD_RELOC_16C_NUM08_C
3819ENUMX
3820  BFD_RELOC_16C_NUM16
3821ENUMX
3822  BFD_RELOC_16C_NUM16_C
3823ENUMX
3824  BFD_RELOC_16C_NUM32
3825ENUMX
3826  BFD_RELOC_16C_NUM32_C
3827ENUMX
3828  BFD_RELOC_16C_DISP04
3829ENUMX
3830  BFD_RELOC_16C_DISP04_C
3831ENUMX
3832  BFD_RELOC_16C_DISP08
3833ENUMX
3834  BFD_RELOC_16C_DISP08_C
3835ENUMX
3836  BFD_RELOC_16C_DISP16
3837ENUMX
3838  BFD_RELOC_16C_DISP16_C
3839ENUMX
3840  BFD_RELOC_16C_DISP24
3841ENUMX
3842  BFD_RELOC_16C_DISP24_C
3843ENUMX
3844  BFD_RELOC_16C_DISP24a
3845ENUMX
3846  BFD_RELOC_16C_DISP24a_C
3847ENUMX
3848  BFD_RELOC_16C_REG04
3849ENUMX
3850  BFD_RELOC_16C_REG04_C
3851ENUMX
3852  BFD_RELOC_16C_REG04a
3853ENUMX
3854  BFD_RELOC_16C_REG04a_C
3855ENUMX
3856  BFD_RELOC_16C_REG14
3857ENUMX
3858  BFD_RELOC_16C_REG14_C
3859ENUMX
3860  BFD_RELOC_16C_REG16
3861ENUMX
3862  BFD_RELOC_16C_REG16_C
3863ENUMX
3864  BFD_RELOC_16C_REG20
3865ENUMX
3866  BFD_RELOC_16C_REG20_C
3867ENUMX
3868  BFD_RELOC_16C_ABS20
3869ENUMX
3870  BFD_RELOC_16C_ABS20_C
3871ENUMX
3872  BFD_RELOC_16C_ABS24
3873ENUMX
3874  BFD_RELOC_16C_ABS24_C
3875ENUMX
3876  BFD_RELOC_16C_IMM04
3877ENUMX
3878  BFD_RELOC_16C_IMM04_C
3879ENUMX
3880  BFD_RELOC_16C_IMM16
3881ENUMX
3882  BFD_RELOC_16C_IMM16_C
3883ENUMX
3884  BFD_RELOC_16C_IMM20
3885ENUMX
3886  BFD_RELOC_16C_IMM20_C
3887ENUMX
3888  BFD_RELOC_16C_IMM24
3889ENUMX
3890  BFD_RELOC_16C_IMM24_C
3891ENUMX
3892  BFD_RELOC_16C_IMM32
3893ENUMX
3894  BFD_RELOC_16C_IMM32_C
3895ENUMDOC
3896  NS CR16C Relocations.
3897
3898ENUM
3899  BFD_RELOC_CRX_REL4
3900ENUMX
3901  BFD_RELOC_CRX_REL8
3902ENUMX
3903  BFD_RELOC_CRX_REL8_CMP
3904ENUMX
3905  BFD_RELOC_CRX_REL16
3906ENUMX
3907  BFD_RELOC_CRX_REL24
3908ENUMX
3909  BFD_RELOC_CRX_REL32
3910ENUMX
3911  BFD_RELOC_CRX_REGREL12
3912ENUMX
3913  BFD_RELOC_CRX_REGREL22
3914ENUMX
3915  BFD_RELOC_CRX_REGREL28
3916ENUMX
3917  BFD_RELOC_CRX_REGREL32
3918ENUMX
3919  BFD_RELOC_CRX_ABS16
3920ENUMX
3921  BFD_RELOC_CRX_ABS32
3922ENUMX
3923  BFD_RELOC_CRX_NUM8
3924ENUMX
3925  BFD_RELOC_CRX_NUM16
3926ENUMX
3927  BFD_RELOC_CRX_NUM32
3928ENUMX
3929  BFD_RELOC_CRX_IMM16
3930ENUMX
3931  BFD_RELOC_CRX_IMM32
3932ENUMX
3933  BFD_RELOC_CRX_SWITCH8
3934ENUMX
3935  BFD_RELOC_CRX_SWITCH16
3936ENUMX
3937  BFD_RELOC_CRX_SWITCH32
3938ENUMDOC
3939  NS CRX Relocations.
3940
3941ENUM
3942  BFD_RELOC_CRIS_BDISP8
3943ENUMX
3944  BFD_RELOC_CRIS_UNSIGNED_5
3945ENUMX
3946  BFD_RELOC_CRIS_SIGNED_6
3947ENUMX
3948  BFD_RELOC_CRIS_UNSIGNED_6
3949ENUMX
3950  BFD_RELOC_CRIS_UNSIGNED_4
3951ENUMDOC
3952  These relocs are only used within the CRIS assembler.  They are not
3953  (at present) written to any object files.
3954ENUM
3955  BFD_RELOC_CRIS_COPY
3956ENUMX
3957  BFD_RELOC_CRIS_GLOB_DAT
3958ENUMX
3959  BFD_RELOC_CRIS_JUMP_SLOT
3960ENUMX
3961  BFD_RELOC_CRIS_RELATIVE
3962ENUMDOC
3963  Relocs used in ELF shared libraries for CRIS.
3964ENUM
3965  BFD_RELOC_CRIS_32_GOT
3966ENUMDOC
3967  32-bit offset to symbol-entry within GOT.
3968ENUM
3969  BFD_RELOC_CRIS_16_GOT
3970ENUMDOC
3971  16-bit offset to symbol-entry within GOT.
3972ENUM
3973  BFD_RELOC_CRIS_32_GOTPLT
3974ENUMDOC
3975  32-bit offset to symbol-entry within GOT, with PLT handling.
3976ENUM
3977  BFD_RELOC_CRIS_16_GOTPLT
3978ENUMDOC
3979  16-bit offset to symbol-entry within GOT, with PLT handling.
3980ENUM
3981  BFD_RELOC_CRIS_32_GOTREL
3982ENUMDOC
3983  32-bit offset to symbol, relative to GOT.
3984ENUM
3985  BFD_RELOC_CRIS_32_PLT_GOTREL
3986ENUMDOC
3987  32-bit offset to symbol with PLT entry, relative to GOT.
3988ENUM
3989  BFD_RELOC_CRIS_32_PLT_PCREL
3990ENUMDOC
3991  32-bit offset to symbol with PLT entry, relative to this relocation.
3992
3993ENUM
3994  BFD_RELOC_860_COPY
3995ENUMX
3996  BFD_RELOC_860_GLOB_DAT
3997ENUMX
3998  BFD_RELOC_860_JUMP_SLOT
3999ENUMX
4000  BFD_RELOC_860_RELATIVE
4001ENUMX
4002  BFD_RELOC_860_PC26
4003ENUMX
4004  BFD_RELOC_860_PLT26
4005ENUMX
4006  BFD_RELOC_860_PC16
4007ENUMX
4008  BFD_RELOC_860_LOW0
4009ENUMX
4010  BFD_RELOC_860_SPLIT0
4011ENUMX
4012  BFD_RELOC_860_LOW1
4013ENUMX
4014  BFD_RELOC_860_SPLIT1
4015ENUMX
4016  BFD_RELOC_860_LOW2
4017ENUMX
4018  BFD_RELOC_860_SPLIT2
4019ENUMX
4020  BFD_RELOC_860_LOW3
4021ENUMX
4022  BFD_RELOC_860_LOGOT0
4023ENUMX
4024  BFD_RELOC_860_SPGOT0
4025ENUMX
4026  BFD_RELOC_860_LOGOT1
4027ENUMX
4028  BFD_RELOC_860_SPGOT1
4029ENUMX
4030  BFD_RELOC_860_LOGOTOFF0
4031ENUMX
4032  BFD_RELOC_860_SPGOTOFF0
4033ENUMX
4034  BFD_RELOC_860_LOGOTOFF1
4035ENUMX
4036  BFD_RELOC_860_SPGOTOFF1
4037ENUMX
4038  BFD_RELOC_860_LOGOTOFF2
4039ENUMX
4040  BFD_RELOC_860_LOGOTOFF3
4041ENUMX
4042  BFD_RELOC_860_LOPC
4043ENUMX
4044  BFD_RELOC_860_HIGHADJ
4045ENUMX
4046  BFD_RELOC_860_HAGOT
4047ENUMX
4048  BFD_RELOC_860_HAGOTOFF
4049ENUMX
4050  BFD_RELOC_860_HAPC
4051ENUMX
4052  BFD_RELOC_860_HIGH
4053ENUMX
4054  BFD_RELOC_860_HIGOT
4055ENUMX
4056  BFD_RELOC_860_HIGOTOFF
4057ENUMDOC
4058  Intel i860 Relocations.
4059
4060ENUM
4061  BFD_RELOC_OPENRISC_ABS_26
4062ENUMX
4063  BFD_RELOC_OPENRISC_REL_26
4064ENUMDOC
4065  OpenRISC Relocations.
4066
4067ENUM
4068  BFD_RELOC_H8_DIR16A8
4069ENUMX
4070  BFD_RELOC_H8_DIR16R8
4071ENUMX
4072  BFD_RELOC_H8_DIR24A8
4073ENUMX
4074  BFD_RELOC_H8_DIR24R8
4075ENUMX
4076  BFD_RELOC_H8_DIR32A16
4077ENUMDOC
4078  H8 elf Relocations.
4079
4080ENUM
4081  BFD_RELOC_XSTORMY16_REL_12
4082ENUMX
4083  BFD_RELOC_XSTORMY16_12
4084ENUMX
4085  BFD_RELOC_XSTORMY16_24
4086ENUMX
4087  BFD_RELOC_XSTORMY16_FPTR16
4088ENUMDOC
4089  Sony Xstormy16 Relocations.
4090
4091ENUM
4092  BFD_RELOC_VAX_GLOB_DAT
4093ENUMX
4094  BFD_RELOC_VAX_JMP_SLOT
4095ENUMX
4096  BFD_RELOC_VAX_RELATIVE
4097ENUMDOC
4098  Relocations used by VAX ELF.
4099
4100ENUM
4101  BFD_RELOC_MSP430_10_PCREL
4102ENUMX
4103  BFD_RELOC_MSP430_16_PCREL
4104ENUMX
4105  BFD_RELOC_MSP430_16
4106ENUMX
4107  BFD_RELOC_MSP430_16_PCREL_BYTE
4108ENUMX
4109  BFD_RELOC_MSP430_16_BYTE
4110ENUMX
4111  BFD_RELOC_MSP430_2X_PCREL
4112ENUMX
4113  BFD_RELOC_MSP430_RL_PCREL
4114ENUMDOC
4115  msp430 specific relocation codes
4116
4117ENUM
4118  BFD_RELOC_IQ2000_OFFSET_16
4119ENUMX
4120  BFD_RELOC_IQ2000_OFFSET_21
4121ENUMX
4122  BFD_RELOC_IQ2000_UHI16
4123ENUMDOC
4124  IQ2000 Relocations.
4125
4126ENUM
4127  BFD_RELOC_XTENSA_RTLD
4128ENUMDOC
4129  Special Xtensa relocation used only by PLT entries in ELF shared
4130  objects to indicate that the runtime linker should set the value
4131  to one of its own internal functions or data structures.
4132ENUM
4133  BFD_RELOC_XTENSA_GLOB_DAT
4134ENUMX
4135  BFD_RELOC_XTENSA_JMP_SLOT
4136ENUMX
4137  BFD_RELOC_XTENSA_RELATIVE
4138ENUMDOC
4139  Xtensa relocations for ELF shared objects.
4140ENUM
4141  BFD_RELOC_XTENSA_PLT
4142ENUMDOC
4143  Xtensa relocation used in ELF object files for symbols that may require
4144  PLT entries.  Otherwise, this is just a generic 32-bit relocation.
4145ENUM
4146  BFD_RELOC_XTENSA_DIFF8
4147ENUMX
4148  BFD_RELOC_XTENSA_DIFF16
4149ENUMX
4150  BFD_RELOC_XTENSA_DIFF32
4151ENUMDOC
4152  Xtensa relocations to mark the difference of two local symbols.
4153  These are only needed to support linker relaxation and can be ignored
4154  when not relaxing.  The field is set to the value of the difference
4155  assuming no relaxation.  The relocation encodes the position of the
4156  first symbol so the linker can determine whether to adjust the field
4157  value.
4158ENUM
4159  BFD_RELOC_XTENSA_SLOT0_OP
4160ENUMX
4161  BFD_RELOC_XTENSA_SLOT1_OP
4162ENUMX
4163  BFD_RELOC_XTENSA_SLOT2_OP
4164ENUMX
4165  BFD_RELOC_XTENSA_SLOT3_OP
4166ENUMX
4167  BFD_RELOC_XTENSA_SLOT4_OP
4168ENUMX
4169  BFD_RELOC_XTENSA_SLOT5_OP
4170ENUMX
4171  BFD_RELOC_XTENSA_SLOT6_OP
4172ENUMX
4173  BFD_RELOC_XTENSA_SLOT7_OP
4174ENUMX
4175  BFD_RELOC_XTENSA_SLOT8_OP
4176ENUMX
4177  BFD_RELOC_XTENSA_SLOT9_OP
4178ENUMX
4179  BFD_RELOC_XTENSA_SLOT10_OP
4180ENUMX
4181  BFD_RELOC_XTENSA_SLOT11_OP
4182ENUMX
4183  BFD_RELOC_XTENSA_SLOT12_OP
4184ENUMX
4185  BFD_RELOC_XTENSA_SLOT13_OP
4186ENUMX
4187  BFD_RELOC_XTENSA_SLOT14_OP
4188ENUMDOC
4189  Generic Xtensa relocations for instruction operands.  Only the slot
4190  number is encoded in the relocation.  The relocation applies to the
4191  last PC-relative immediate operand, or if there are no PC-relative
4192  immediates, to the last immediate operand.
4193ENUM
4194  BFD_RELOC_XTENSA_SLOT0_ALT
4195ENUMX
4196  BFD_RELOC_XTENSA_SLOT1_ALT
4197ENUMX
4198  BFD_RELOC_XTENSA_SLOT2_ALT
4199ENUMX
4200  BFD_RELOC_XTENSA_SLOT3_ALT
4201ENUMX
4202  BFD_RELOC_XTENSA_SLOT4_ALT
4203ENUMX
4204  BFD_RELOC_XTENSA_SLOT5_ALT
4205ENUMX
4206  BFD_RELOC_XTENSA_SLOT6_ALT
4207ENUMX
4208  BFD_RELOC_XTENSA_SLOT7_ALT
4209ENUMX
4210  BFD_RELOC_XTENSA_SLOT8_ALT
4211ENUMX
4212  BFD_RELOC_XTENSA_SLOT9_ALT
4213ENUMX
4214  BFD_RELOC_XTENSA_SLOT10_ALT
4215ENUMX
4216  BFD_RELOC_XTENSA_SLOT11_ALT
4217ENUMX
4218  BFD_RELOC_XTENSA_SLOT12_ALT
4219ENUMX
4220  BFD_RELOC_XTENSA_SLOT13_ALT
4221ENUMX
4222  BFD_RELOC_XTENSA_SLOT14_ALT
4223ENUMDOC
4224  Alternate Xtensa relocations.  Only the slot is encoded in the
4225  relocation.  The meaning of these relocations is opcode-specific.
4226ENUM
4227  BFD_RELOC_XTENSA_OP0
4228ENUMX
4229  BFD_RELOC_XTENSA_OP1
4230ENUMX
4231  BFD_RELOC_XTENSA_OP2
4232ENUMDOC
4233  Xtensa relocations for backward compatibility.  These have all been
4234  replaced by BFD_RELOC_XTENSA_SLOT0_OP.
4235ENUM
4236  BFD_RELOC_XTENSA_ASM_EXPAND
4237ENUMDOC
4238  Xtensa relocation to mark that the assembler expanded the
4239  instructions from an original target.  The expansion size is
4240  encoded in the reloc size.
4241ENUM
4242  BFD_RELOC_XTENSA_ASM_SIMPLIFY
4243ENUMDOC
4244  Xtensa relocation to mark that the linker should simplify
4245  assembler-expanded instructions.  This is commonly used
4246  internally by the linker after analysis of a
4247  BFD_RELOC_XTENSA_ASM_EXPAND.
4248
4249ENDSENUM
4250  BFD_RELOC_UNUSED
4251CODE_FRAGMENT
4252.
4253.typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
4254*/
4255
4256/*
4257FUNCTION
4258	bfd_reloc_type_lookup
4259
4260SYNOPSIS
4261	reloc_howto_type *bfd_reloc_type_lookup
4262	  (bfd *abfd, bfd_reloc_code_real_type code);
4263
4264DESCRIPTION
4265	Return a pointer to a howto structure which, when
4266	invoked, will perform the relocation @var{code} on data from the
4267	architecture noted.
4268
4269*/
4270
4271reloc_howto_type *
4272bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
4273{
4274  return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
4275}
4276
4277static reloc_howto_type bfd_howto_32 =
4278HOWTO (0, 00, 2, 32, FALSE, 0, complain_overflow_bitfield, 0, "VRT32", FALSE, 0xffffffff, 0xffffffff, TRUE);
4279
4280/*
4281INTERNAL_FUNCTION
4282	bfd_default_reloc_type_lookup
4283
4284SYNOPSIS
4285	reloc_howto_type *bfd_default_reloc_type_lookup
4286	  (bfd *abfd, bfd_reloc_code_real_type  code);
4287
4288DESCRIPTION
4289	Provides a default relocation lookup routine for any architecture.
4290
4291*/
4292
4293reloc_howto_type *
4294bfd_default_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code)
4295{
4296  switch (code)
4297    {
4298    case BFD_RELOC_CTOR:
4299      /* The type of reloc used in a ctor, which will be as wide as the
4300	 address - so either a 64, 32, or 16 bitter.  */
4301      switch (bfd_get_arch_info (abfd)->bits_per_address)
4302	{
4303	case 64:
4304	  BFD_FAIL ();
4305	case 32:
4306	  return &bfd_howto_32;
4307	case 16:
4308	  BFD_FAIL ();
4309	default:
4310	  BFD_FAIL ();
4311	}
4312    default:
4313      BFD_FAIL ();
4314    }
4315  return NULL;
4316}
4317
4318/*
4319FUNCTION
4320	bfd_get_reloc_code_name
4321
4322SYNOPSIS
4323	const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
4324
4325DESCRIPTION
4326	Provides a printable name for the supplied relocation code.
4327	Useful mainly for printing error messages.
4328*/
4329
4330const char *
4331bfd_get_reloc_code_name (bfd_reloc_code_real_type code)
4332{
4333  if (code > BFD_RELOC_UNUSED)
4334    return 0;
4335  return bfd_reloc_code_real_names[code];
4336}
4337
4338/*
4339INTERNAL_FUNCTION
4340	bfd_generic_relax_section
4341
4342SYNOPSIS
4343	bfd_boolean bfd_generic_relax_section
4344	  (bfd *abfd,
4345	   asection *section,
4346	   struct bfd_link_info *,
4347	   bfd_boolean *);
4348
4349DESCRIPTION
4350	Provides default handling for relaxing for back ends which
4351	don't do relaxing.
4352*/
4353
4354bfd_boolean
4355bfd_generic_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
4356			   asection *section ATTRIBUTE_UNUSED,
4357			   struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
4358			   bfd_boolean *again)
4359{
4360  *again = FALSE;
4361  return TRUE;
4362}
4363
4364/*
4365INTERNAL_FUNCTION
4366	bfd_generic_gc_sections
4367
4368SYNOPSIS
4369	bfd_boolean bfd_generic_gc_sections
4370	  (bfd *, struct bfd_link_info *);
4371
4372DESCRIPTION
4373	Provides default handling for relaxing for back ends which
4374	don't do section gc -- i.e., does nothing.
4375*/
4376
4377bfd_boolean
4378bfd_generic_gc_sections (bfd *abfd ATTRIBUTE_UNUSED,
4379			 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
4380{
4381  return TRUE;
4382}
4383
4384/*
4385INTERNAL_FUNCTION
4386	bfd_generic_merge_sections
4387
4388SYNOPSIS
4389	bfd_boolean bfd_generic_merge_sections
4390	  (bfd *, struct bfd_link_info *);
4391
4392DESCRIPTION
4393	Provides default handling for SEC_MERGE section merging for back ends
4394	which don't have SEC_MERGE support -- i.e., does nothing.
4395*/
4396
4397bfd_boolean
4398bfd_generic_merge_sections (bfd *abfd ATTRIBUTE_UNUSED,
4399			    struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
4400{
4401  return TRUE;
4402}
4403
4404/*
4405INTERNAL_FUNCTION
4406	bfd_generic_get_relocated_section_contents
4407
4408SYNOPSIS
4409	bfd_byte *bfd_generic_get_relocated_section_contents
4410	  (bfd *abfd,
4411	   struct bfd_link_info *link_info,
4412	   struct bfd_link_order *link_order,
4413	   bfd_byte *data,
4414	   bfd_boolean relocatable,
4415	   asymbol **symbols);
4416
4417DESCRIPTION
4418	Provides default handling of relocation effort for back ends
4419	which can't be bothered to do it efficiently.
4420
4421*/
4422
4423bfd_byte *
4424bfd_generic_get_relocated_section_contents (bfd *abfd,
4425					    struct bfd_link_info *link_info,
4426					    struct bfd_link_order *link_order,
4427					    bfd_byte *data,
4428					    bfd_boolean relocatable,
4429					    asymbol **symbols)
4430{
4431  /* Get enough memory to hold the stuff.  */
4432  bfd *input_bfd = link_order->u.indirect.section->owner;
4433  asection *input_section = link_order->u.indirect.section;
4434
4435  long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
4436  arelent **reloc_vector = NULL;
4437  long reloc_count;
4438  bfd_size_type sz;
4439
4440  if (reloc_size < 0)
4441    goto error_return;
4442
4443  reloc_vector = bfd_malloc (reloc_size);
4444  if (reloc_vector == NULL && reloc_size != 0)
4445    goto error_return;
4446
4447  /* Read in the section.  */
4448  sz = input_section->rawsize ? input_section->rawsize : input_section->size;
4449  if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
4450    goto error_return;
4451
4452  reloc_count = bfd_canonicalize_reloc (input_bfd,
4453					input_section,
4454					reloc_vector,
4455					symbols);
4456  if (reloc_count < 0)
4457    goto error_return;
4458
4459  if (reloc_count > 0)
4460    {
4461      arelent **parent;
4462      for (parent = reloc_vector; *parent != NULL; parent++)
4463	{
4464	  char *error_message = NULL;
4465	  bfd_reloc_status_type r =
4466	    bfd_perform_relocation (input_bfd,
4467				    *parent,
4468				    data,
4469				    input_section,
4470				    relocatable ? abfd : NULL,
4471				    &error_message);
4472
4473	  if (relocatable)
4474	    {
4475	      asection *os = input_section->output_section;
4476
4477	      /* A partial link, so keep the relocs.  */
4478	      os->orelocation[os->reloc_count] = *parent;
4479	      os->reloc_count++;
4480	    }
4481
4482	  if (r != bfd_reloc_ok)
4483	    {
4484	      switch (r)
4485		{
4486		case bfd_reloc_undefined:
4487		  if (!((*link_info->callbacks->undefined_symbol)
4488			(link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
4489			 input_bfd, input_section, (*parent)->address,
4490			 TRUE)))
4491		    goto error_return;
4492		  break;
4493		case bfd_reloc_dangerous:
4494		  BFD_ASSERT (error_message != NULL);
4495		  if (!((*link_info->callbacks->reloc_dangerous)
4496			(link_info, error_message, input_bfd, input_section,
4497			 (*parent)->address)))
4498		    goto error_return;
4499		  break;
4500		case bfd_reloc_overflow:
4501		  if (!((*link_info->callbacks->reloc_overflow)
4502			(link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
4503			 (*parent)->howto->name, (*parent)->addend,
4504			 input_bfd, input_section, (*parent)->address)))
4505		    goto error_return;
4506		  break;
4507		case bfd_reloc_outofrange:
4508		default:
4509		  abort ();
4510		  break;
4511		}
4512
4513	    }
4514	}
4515    }
4516  if (reloc_vector != NULL)
4517    free (reloc_vector);
4518  return data;
4519
4520error_return:
4521  if (reloc_vector != NULL)
4522    free (reloc_vector);
4523  return NULL;
4524}
4525